file_name
stringlengths 5
52
| name
stringlengths 4
95
| original_source_type
stringlengths 0
23k
| source_type
stringlengths 9
23k
| source_definition
stringlengths 9
57.9k
| source
dict | source_range
dict | file_context
stringlengths 0
721k
| dependencies
dict | opens_and_abbrevs
listlengths 2
94
| vconfig
dict | interleaved
bool 1
class | verbose_type
stringlengths 1
7.42k
| effect
stringclasses 118
values | effect_flags
sequencelengths 0
2
| mutual_with
sequencelengths 0
11
| ideal_premises
sequencelengths 0
236
| proof_features
sequencelengths 0
1
| is_simple_lemma
bool 2
classes | is_div
bool 2
classes | is_proof
bool 2
classes | is_simply_typed
bool 2
classes | is_type
bool 2
classes | partial_definition
stringlengths 5
3.99k
| completed_definiton
stringlengths 1
1.63M
| isa_cross_project_example
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_1_from_to | val modifies_1_from_to
(#a: Type0)
(#rrel #rel: srel a)
(b: mbuffer a rrel rel)
(from to: U32.t)
(h1 h2: HS.mem)
: GTot Type0 | val modifies_1_from_to
(#a: Type0)
(#rrel #rel: srel a)
(b: mbuffer a rrel rel)
(from to: U32.t)
(h1 h2: HS.mem)
: GTot Type0 | let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2 | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 657,
"start_col": 0,
"start_line": 648
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
from: FStar.UInt32.t ->
to: FStar.UInt32.t ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer_from_to_none_cond",
"LowStar.Monotonic.Buffer.modifies_0",
"Prims.bool",
"Prims.l_and",
"LowStar.Monotonic.Buffer.modifies_0_preserves_regions",
"LowStar.Monotonic.Buffer.modifies_1_preserves_mreferences",
"LowStar.Monotonic.Buffer.modifies_1_preserves_livenesses",
"LowStar.Monotonic.Buffer.modifies_0_preserves_not_unused_in",
"LowStar.Monotonic.Buffer.modifies_1_from_to_preserves_ubuffers"
] | [] | false | false | false | false | true | let modifies_1_from_to
(#a: Type0)
(#rrel #rel: srel a)
(b: mbuffer a rrel rel)
(from to: U32.t)
(h1 h2: HS.mem)
: GTot Type0 =
| if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\ modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\ modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2 | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.liveness_preservation_intro | val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b)) | val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b)) | let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 552,
"start_col": 0,
"start_line": 549
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem ->
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
f:
(
t': Type0 ->
pre: FStar.Preorder.preorder t' ->
r: FStar.Monotonic.HyperStack.mreference t' pre
-> FStar.Pervasives.Lemma
(requires
FStar.Monotonic.HyperStack.frameOf r == LowStar.Monotonic.Buffer.frameOf b /\
FStar.Monotonic.HyperStack.as_addr r == LowStar.Monotonic.Buffer.as_addr b /\
FStar.Monotonic.HyperStack.contains h r)
(ensures FStar.Monotonic.HyperStack.contains h' r))
-> FStar.Pervasives.Lemma (requires LowStar.Monotonic.Buffer.live h b)
(ensures LowStar.Monotonic.Buffer.live h' b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"Prims.unit",
"Prims.l_and",
"Prims.eq2",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Monotonic.HyperStack.frameOf",
"LowStar.Monotonic.Buffer.frameOf",
"Prims.int",
"Prims.l_or",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_GreaterThan",
"FStar.Monotonic.HyperStack.as_addr",
"LowStar.Monotonic.Buffer.as_addr",
"FStar.Monotonic.HyperStack.contains",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowStar.Monotonic.Buffer.uu___is_Null",
"Prims.bool",
"FStar.Seq.Properties.lseq",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.__proj__Buffer__item__max_length",
"LowStar.Monotonic.Buffer.srel_to_lsrel",
"LowStar.Monotonic.Buffer.__proj__Buffer__item__content"
] | [] | false | false | true | false | false | let liveness_preservation_intro #_ #_ #_ _ _ b f =
| if Null? b then () else f _ _ (Buffer?.content b) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.ubuffer_preserved_intro | val ubuffer_preserved_intro
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h': HS.mem)
(f0:
(t': Type0 -> rrel: srel t' -> rel: srel t' -> b': mbuffer t' rrel rel
-> Lemma (requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))))
(f:
(t': Type0 -> rrel: srel t' -> rel: srel t' -> b': mbuffer t' rrel rel
-> Lemma
(requires
(frameOf b' == r /\ as_addr b' == a /\ live h b' /\ live h' b' /\ Buffer? b' /\
(let { b_max_length = bmax ; b_offset = boff ; b_length = blen } =
Ghost.reveal b
in
let Buffer max _ idx len = b' in
(U32.v max == bmax /\ U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len))))
(ensures
(Buffer? b' /\
(let { b_max_length = bmax ; b_offset = boff ; b_length = blen } =
Ghost.reveal b
in
let Buffer max _ idx len = b' in
U32.v max == bmax /\ U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b')
(boff - U32.v idx)
(boff - U32.v idx + blen))
(Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen)))))
))
: Lemma (ubuffer_preserved b h h') | val ubuffer_preserved_intro
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h': HS.mem)
(f0:
(t': Type0 -> rrel: srel t' -> rel: srel t' -> b': mbuffer t' rrel rel
-> Lemma (requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))))
(f:
(t': Type0 -> rrel: srel t' -> rel: srel t' -> b': mbuffer t' rrel rel
-> Lemma
(requires
(frameOf b' == r /\ as_addr b' == a /\ live h b' /\ live h' b' /\ Buffer? b' /\
(let { b_max_length = bmax ; b_offset = boff ; b_length = blen } =
Ghost.reveal b
in
let Buffer max _ idx len = b' in
(U32.v max == bmax /\ U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len))))
(ensures
(Buffer? b' /\
(let { b_max_length = bmax ; b_offset = boff ; b_length = blen } =
Ghost.reveal b
in
let Buffer max _ idx len = b' in
U32.v max == bmax /\ U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b')
(boff - U32.v idx)
(boff - U32.v idx + blen))
(Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen)))))
))
: Lemma (ubuffer_preserved b h h') | let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g' | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 362,
"start_col": 0,
"start_line": 304
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.ubuffer r a ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem ->
f0:
(
t': Type0 ->
rrel: LowStar.Monotonic.Buffer.srel t' ->
rel: LowStar.Monotonic.Buffer.srel t' ->
b': LowStar.Monotonic.Buffer.mbuffer t' rrel rel
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.frameOf b' == r /\ LowStar.Monotonic.Buffer.as_addr b' == a /\
LowStar.Monotonic.Buffer.live h b') (ensures LowStar.Monotonic.Buffer.live h' b')) ->
f:
(
t': Type0 ->
rrel: LowStar.Monotonic.Buffer.srel t' ->
rel: LowStar.Monotonic.Buffer.srel t' ->
b': LowStar.Monotonic.Buffer.mbuffer t' rrel rel
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.frameOf b' == r /\ LowStar.Monotonic.Buffer.as_addr b' == a /\
LowStar.Monotonic.Buffer.live h b' /\ LowStar.Monotonic.Buffer.live h' b' /\
Buffer? b' /\
(let _ = FStar.Ghost.reveal b in
(let { b_max_length = bmax ; b_offset = boff ; b_length = blen ; b_is_mm = _ } =
_
in
let _ = b' in
(let LowStar.Monotonic.Buffer.Buffer #_ #_ #_ max _ idx len = _ in
FStar.UInt32.v max == bmax /\ FStar.UInt32.v idx <= boff /\
boff + blen <= FStar.UInt32.v idx + FStar.UInt32.v (FStar.Ghost.reveal len))
<:
Prims.logical)
<:
Prims.logical))
(ensures
Buffer? b' /\
(let _ = FStar.Ghost.reveal b in
(let { b_max_length = bmax ; b_offset = boff ; b_length = blen ; b_is_mm = _ } =
_
in
let _ = b' in
(let LowStar.Monotonic.Buffer.Buffer #_ #_ #_ max _ idx len = _ in
FStar.UInt32.v max == bmax /\ FStar.UInt32.v idx <= boff /\
boff + blen <= FStar.UInt32.v idx + FStar.UInt32.v (FStar.Ghost.reveal len) /\
FStar.Seq.Base.equal (FStar.Seq.Base.slice (LowStar.Monotonic.Buffer.as_seq h
b')
(boff - FStar.UInt32.v idx)
(boff - FStar.UInt32.v idx + blen))
(FStar.Seq.Base.slice (LowStar.Monotonic.Buffer.as_seq h' b')
(boff - FStar.UInt32.v idx)
(boff - FStar.UInt32.v idx + blen)))
<:
Prims.logical)
<:
Prims.logical)))
-> FStar.Pervasives.Lemma (ensures LowStar.Monotonic.Buffer.ubuffer_preserved b h h') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"Prims.nat",
"LowStar.Monotonic.Buffer.ubuffer",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.unit",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.live",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims.b2t",
"LowStar.Monotonic.Buffer.uu___is_Buffer",
"Prims.bool",
"FStar.UInt32.t",
"FStar.HyperStack.ST.mreference",
"FStar.Seq.Properties.lseq",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.srel_to_lsrel",
"FStar.Ghost.erased",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.Ghost.reveal",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.logical",
"LowStar.Monotonic.Buffer.ubuffer'",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"LowStar.Monotonic.Buffer.as_seq",
"Prims.op_Subtraction",
"FStar.Classical.forall_intro_4",
"Prims.l_imp",
"FStar.Preorder.preorder",
"FStar.Seq.Base.seq",
"Prims.l_True",
"FStar.Classical.move_requires",
"LowStar.Monotonic.Buffer.ubuffer_preserved"
] | [] | false | false | true | false | false | let ubuffer_preserved_intro
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h': HS.mem)
(f0:
(t': Type0 -> rrel: srel t' -> rel: srel t' -> b': mbuffer t' rrel rel
-> Lemma (requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))))
(f:
(t': Type0 -> rrel: srel t' -> rel: srel t' -> b': mbuffer t' rrel rel
-> Lemma
(requires
(frameOf b' == r /\ as_addr b' == a /\ live h b' /\ live h' b' /\ Buffer? b' /\
(let { b_max_length = bmax ; b_offset = boff ; b_length = blen } =
Ghost.reveal b
in
let Buffer max _ idx len = b' in
(U32.v max == bmax /\ U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len))))
(ensures
(Buffer? b' /\
(let { b_max_length = bmax ; b_offset = boff ; b_length = blen } =
Ghost.reveal b
in
let Buffer max _ idx len = b' in
U32.v max == bmax /\ U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b')
(boff - U32.v idx)
(boff - U32.v idx + blen))
(Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen)))))
))
: Lemma (ubuffer_preserved b h h') =
| let g' (t': Type0) (rrel rel: srel t') (b': mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==>
((live h b' ==> live h' b') /\
(((live h b' /\ live h' b' /\ Buffer? b') ==>
(let { b_max_length = bmax ; b_offset = boff ; b_length = blen } = Ghost.reveal b in
let Buffer max _ idx len = b' in
(U32.v max == bmax /\ U32.v idx <= boff /\ boff + blen <= U32.v idx + U32.v len) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen))
(Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))))))) =
Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g' | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_addr_of | val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 | val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 | let modifies_addr_of = modifies_addr_of' | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 741,
"start_col": 0,
"start_line": 741
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Monotonic.Buffer.modifies_addr_of'"
] | [] | false | false | false | false | true | let modifies_addr_of =
| modifies_addr_of' | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_addr_of' | val modifies_addr_of' (#a: Type0) (#rrel #rel: srel a) (b: mbuffer a rrel rel) (h1 h2: HS.mem)
: GTot Type0 | val modifies_addr_of' (#a: Type0) (#rrel #rel: srel a) (b: mbuffer a rrel rel) (h1 h2: HS.mem)
: GTot Type0 | let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2 | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 738,
"start_col": 0,
"start_line": 735
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"LowStar.Monotonic.Buffer.modifies_0_preserves_regions",
"LowStar.Monotonic.Buffer.modifies_1_preserves_mreferences",
"LowStar.Monotonic.Buffer.modifies_addr_of_preserves_not_unused_in"
] | [] | false | false | false | false | true | let modifies_addr_of' (#a: Type0) (#rrel #rel: srel a) (b: mbuffer a rrel rel) (h1 h2: HS.mem)
: GTot Type0 =
| modifies_0_preserves_regions h1 h2 /\ modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2 | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_0_ubuffer | val modifies_0_ubuffer (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2: HS.mem)
: Lemma (requires (modifies_0 h1 h2)) (ensures (ubuffer_preserved b h1 h2)) | val modifies_0_ubuffer (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2: HS.mem)
: Lemma (requires (modifies_0 h1 h2)) (ensures (ubuffer_preserved b h1 h2)) | let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r') | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 93,
"end_line": 600,
"start_col": 0,
"start_line": 592
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.ubuffer r a ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires LowStar.Monotonic.Buffer.modifies_0 h1 h2)
(ensures LowStar.Monotonic.Buffer.ubuffer_preserved b h1 h2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"Prims.nat",
"LowStar.Monotonic.Buffer.ubuffer",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.same_mreference_ubuffer_preserved",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"LowStar.Monotonic.Buffer.modifies_0_mreference",
"Prims.unit",
"LowStar.Monotonic.Buffer.modifies_0",
"Prims.squash",
"LowStar.Monotonic.Buffer.ubuffer_preserved",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let modifies_0_ubuffer (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2: HS.mem)
: Lemma (requires (modifies_0 h1 h2)) (ensures (ubuffer_preserved b h1 h2)) =
| same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r') | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_1_preserves_mreferences | val modifies_1_preserves_mreferences
(#a: Type0)
(#rrel #rel: srel a)
(b: mbuffer a rrel rel)
(h1 h2: HS.mem)
: GTot Type0 | val modifies_1_preserves_mreferences
(#a: Type0)
(#rrel #rel: srel a)
(b: mbuffer a rrel rel)
(h1 h2: HS.mem)
: GTot Type0 | let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r') | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 620,
"start_col": 0,
"start_line": 616
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_Forall",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"Prims.l_imp",
"Prims.l_and",
"Prims.l_or",
"Prims.b2t",
"Prims.op_disEquality",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"FStar.Monotonic.HyperStack.frameOf",
"Prims.int",
"Prims.op_GreaterThanOrEqual",
"Prims.op_GreaterThan",
"LowStar.Monotonic.Buffer.as_addr",
"FStar.Monotonic.HyperStack.as_addr",
"FStar.Monotonic.HyperStack.contains",
"Prims.eq2",
"FStar.Monotonic.HyperStack.sel"
] | [] | false | false | false | false | true | let modifies_1_preserves_mreferences
(#a: Type0)
(#rrel #rel: srel a)
(b: mbuffer a rrel rel)
(h1 h2: HS.mem)
: GTot Type0 =
| forall (a': Type) (pre: Preorder.preorder a') (r': HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r') | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_union | val loc_union
(s1 s2: loc)
: GTot loc | val loc_union
(s1 s2: loc)
: GTot loc | let loc_union = MG.loc_union | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 785,
"start_col": 0,
"start_line": 785
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s1: LowStar.Monotonic.Buffer.loc -> s2: LowStar.Monotonic.Buffer.loc
-> Prims.GTot LowStar.Monotonic.Buffer.loc | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.ModifiesGen.loc_union",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | false | false | false | false | false | let loc_union =
| MG.loc_union | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_none | val loc_none: loc | val loc_none: loc | let loc_none = MG.loc_none | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 782,
"start_col": 0,
"start_line": 782
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | LowStar.Monotonic.Buffer.loc | Prims.Tot | [
"total"
] | [] | [
"FStar.ModifiesGen.loc_none",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | false | false | false | true | false | let loc_none =
| MG.loc_none | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc | val loc : Type0 | val loc : Type0 | let loc = MG.loc cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 779,
"start_col": 0,
"start_line": 779
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.ModifiesGen.loc",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | false | false | false | true | true | let loc =
| MG.loc cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_buffer_from_to | val loc_buffer_from_to (#a:Type0) (#rrel #rel:srel a) (b: mbuffer a rrel rel) (from to: U32.t) : GTot loc | val loc_buffer_from_to (#a:Type0) (#rrel #rel:srel a) (b: mbuffer a rrel rel) (from to: U32.t) : GTot loc | let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 88,
"end_line": 802,
"start_col": 0,
"start_line": 798
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: LowStar.Monotonic.Buffer.mbuffer a rrel rel -> from: FStar.UInt32.t -> to: FStar.UInt32.t
-> Prims.GTot LowStar.Monotonic.Buffer.loc | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer_from_to_none_cond",
"FStar.ModifiesGen.loc_none",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"Prims.bool",
"FStar.ModifiesGen.loc_of_aloc",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer_from_to",
"LowStar.Monotonic.Buffer.loc"
] | [] | false | false | false | false | false | let loc_buffer_from_to #a #rrel #rel b from to =
| if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_buffer | val loc_buffer (#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel) :GTot loc | val loc_buffer (#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel) :GTot loc | let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 75,
"end_line": 806,
"start_col": 0,
"start_line": 804
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: LowStar.Monotonic.Buffer.mbuffer a rrel rel -> Prims.GTot LowStar.Monotonic.Buffer.loc | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.ModifiesGen.loc_none",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"Prims.bool",
"FStar.ModifiesGen.loc_of_aloc",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer",
"LowStar.Monotonic.Buffer.loc"
] | [] | false | false | false | false | false | let loc_buffer #_ #_ #_ b =
| if g_is_null b
then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_addr_of_preserves_not_unused_in | val modifies_addr_of_preserves_not_unused_in
(#a: Type0)
(#rrel #rel: srel a)
(b: mbuffer a rrel rel)
(h1 h2: HS.mem)
: GTot Type0 | val modifies_addr_of_preserves_not_unused_in
(#a: Type0)
(#rrel #rel: srel a)
(b: mbuffer a rrel rel)
(h1 h2: HS.mem)
: GTot Type0 | let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 60,
"end_line": 733,
"start_col": 0,
"start_line": 727
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_Forall",
"FStar.Monotonic.HyperHeap.rid",
"Prims.nat",
"Prims.l_imp",
"Prims.l_and",
"Prims.l_or",
"Prims.b2t",
"Prims.op_disEquality",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"FStar.Monotonic.HyperStack.live_region",
"FStar.Monotonic.Heap.addr_unused_in",
"FStar.Map.sel",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.HyperStack.get_hmap"
] | [] | false | false | false | false | true | let modifies_addr_of_preserves_not_unused_in
(#a: Type0)
(#rrel #rel: srel a)
(b: mbuffer a rrel rel)
(h1 h2: HS.mem)
: GTot Type0 =
| forall (r: HS.rid) (n: nat).
((r <> frameOf b \/ n <> as_addr b) /\ HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` ((HS.get_hmap h2) `Map.sel` r)) ==>
(n `Heap.addr_unused_in` ((HS.get_hmap h1) `Map.sel` r)) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_union_loc_none_l | val loc_union_loc_none_l
(s: loc)
: Lemma
(loc_union loc_none s == s)
[SMTPat (loc_union loc_none s)] | val loc_union_loc_none_l
(s: loc)
: Lemma
(loc_union loc_none s == s)
[SMTPat (loc_union loc_none s)] | let loc_union_loc_none_l = MG.loc_union_loc_none_l | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 794,
"start_col": 0,
"start_line": 794
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma
(ensures LowStar.Monotonic.Buffer.loc_union LowStar.Monotonic.Buffer.loc_none s == s)
[SMTPat (LowStar.Monotonic.Buffer.loc_union LowStar.Monotonic.Buffer.loc_none s)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_union_loc_none_l",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_union_loc_none_l =
| MG.loc_union_loc_none_l | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_union_loc_none_r | val loc_union_loc_none_r
(s: loc)
: Lemma
(loc_union s loc_none == s)
[SMTPat (loc_union s loc_none)] | val loc_union_loc_none_r
(s: loc)
: Lemma
(loc_union s loc_none == s)
[SMTPat (loc_union s loc_none)] | let loc_union_loc_none_r = MG.loc_union_loc_none_r | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 796,
"start_col": 0,
"start_line": 796
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma
(ensures LowStar.Monotonic.Buffer.loc_union s LowStar.Monotonic.Buffer.loc_none == s)
[SMTPat (LowStar.Monotonic.Buffer.loc_union s LowStar.Monotonic.Buffer.loc_none)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_union_loc_none_r",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_union_loc_none_r =
| MG.loc_union_loc_none_r | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_regions | val loc_regions
(preserve_liveness: bool)
(r: Set.set HS.rid)
: GTot loc | val loc_regions
(preserve_liveness: bool)
(r: Set.set HS.rid)
: GTot loc | let loc_regions = MG.loc_regions | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 826,
"start_col": 0,
"start_line": 826
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | preserve_liveness: Prims.bool -> r: FStar.Set.set FStar.Monotonic.HyperHeap.rid
-> Prims.GTot LowStar.Monotonic.Buffer.loc | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.ModifiesGen.loc_regions",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | false | false | false | false | false | let loc_regions =
| MG.loc_regions | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_union_comm | val loc_union_comm
(s1 s2: loc)
: Lemma
(loc_union s1 s2 == loc_union s2 s1)
[SMTPat (loc_union s1 s2)] | val loc_union_comm
(s1 s2: loc)
: Lemma
(loc_union s1 s2 == loc_union s2 s1)
[SMTPat (loc_union s1 s2)] | let loc_union_comm = MG.loc_union_comm | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 790,
"start_col": 0,
"start_line": 790
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s1: LowStar.Monotonic.Buffer.loc -> s2: LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma
(ensures LowStar.Monotonic.Buffer.loc_union s1 s2 == LowStar.Monotonic.Buffer.loc_union s2 s1)
[SMTPat (LowStar.Monotonic.Buffer.loc_union s1 s2)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_union_comm",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_union_comm =
| MG.loc_union_comm | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_union_idem | val loc_union_idem
(s: loc)
: Lemma
(loc_union s s == s)
[SMTPat (loc_union s s)] | val loc_union_idem
(s: loc)
: Lemma
(loc_union s s == s)
[SMTPat (loc_union s s)] | let loc_union_idem = MG.loc_union_idem | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 788,
"start_col": 0,
"start_line": 788
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma (ensures LowStar.Monotonic.Buffer.loc_union s s == s)
[SMTPat (LowStar.Monotonic.Buffer.loc_union s s)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_union_idem",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_union_idem =
| MG.loc_union_idem | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_union_assoc | val loc_union_assoc
(s1 s2 s3: loc)
: Lemma
(loc_union s1 (loc_union s2 s3) == loc_union (loc_union s1 s2) s3) | val loc_union_assoc
(s1 s2 s3: loc)
: Lemma
(loc_union s1 (loc_union s2 s3) == loc_union (loc_union s1 s2) s3) | let loc_union_assoc = MG.loc_union_assoc | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 792,
"start_col": 0,
"start_line": 792
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s1: LowStar.Monotonic.Buffer.loc ->
s2: LowStar.Monotonic.Buffer.loc ->
s3: LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma
(ensures
LowStar.Monotonic.Buffer.loc_union s1 (LowStar.Monotonic.Buffer.loc_union s2 s3) ==
LowStar.Monotonic.Buffer.loc_union (LowStar.Monotonic.Buffer.loc_union s1 s2) s3) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_union_assoc",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_union_assoc =
| MG.loc_union_assoc | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes | val loc_includes
(s1 s2: loc)
: GTot Type0 | val loc_includes
(s1 s2: loc)
: GTot Type0 | let loc_includes = MG.loc_includes | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 828,
"start_col": 0,
"start_line": 828
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s1: LowStar.Monotonic.Buffer.loc -> s2: LowStar.Monotonic.Buffer.loc -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.ModifiesGen.loc_includes",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | false | false | false | false | true | let loc_includes =
| MG.loc_includes | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.cls | val cls:MG.cls ubuffer | val cls:MG.cls ubuffer | let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 70,
"end_line": 777,
"start_col": 0,
"start_line": 767
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.ModifiesGen.cls LowStar.Monotonic.Buffer.ubuffer | Prims.Tot | [
"total"
] | [] | [
"FStar.ModifiesGen.Cls",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.ubuffer_includes",
"FStar.Monotonic.HyperHeap.rid",
"Prims.nat",
"LowStar.Monotonic.Buffer.ubuffer_includes_refl",
"Prims.unit",
"LowStar.Monotonic.Buffer.ubuffer_includes_trans",
"LowStar.Monotonic.Buffer.ubuffer_disjoint",
"LowStar.Monotonic.Buffer.ubuffer_disjoint_sym",
"LowStar.Monotonic.Buffer.ubuffer_disjoint_includes",
"LowStar.Monotonic.Buffer.ubuffer_preserved",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.ubuffer_preserved_refl",
"LowStar.Monotonic.Buffer.ubuffer_preserved_trans",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"Prims.l_and",
"FStar.Monotonic.HyperStack.contains",
"Prims.eq2",
"FStar.Monotonic.HyperStack.frameOf",
"Prims.int",
"Prims.l_or",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_GreaterThanOrEqual",
"FStar.Monotonic.HyperStack.as_addr",
"Prims.squash",
"FStar.Monotonic.HyperStack.sel",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowStar.Monotonic.Buffer.same_mreference_ubuffer_preserved"
] | [] | false | false | false | true | false | let cls:MG.cls ubuffer =
| MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 ->
ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_disjoint | val loc_disjoint
(s1 s2: loc)
: GTot Type0 | val loc_disjoint
(s1 s2: loc)
: GTot Type0 | let loc_disjoint = MG.loc_disjoint | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 898,
"start_col": 0,
"start_line": 898
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s1: LowStar.Monotonic.Buffer.loc -> s2: LowStar.Monotonic.Buffer.loc -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.ModifiesGen.loc_disjoint",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | false | false | false | false | true | let loc_disjoint =
| MG.loc_disjoint | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_addresses | val loc_addresses
(preserve_liveness: bool)
(r: HS.rid)
(n: Set.set nat)
: GTot loc | val loc_addresses
(preserve_liveness: bool)
(r: HS.rid)
(n: Set.set nat)
: GTot loc | let loc_addresses = MG.loc_addresses | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 824,
"start_col": 0,
"start_line": 824
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | preserve_liveness: Prims.bool -> r: FStar.Monotonic.HyperHeap.rid -> n: FStar.Set.set Prims.nat
-> Prims.GTot LowStar.Monotonic.Buffer.loc | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.ModifiesGen.loc_addresses",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | false | false | false | false | false | let loc_addresses =
| MG.loc_addresses | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_none | val loc_includes_none
(s: loc)
: Lemma
(loc_includes s loc_none)
[SMTPat (loc_includes s loc_none)] | val loc_includes_none
(s: loc)
: Lemma
(loc_includes s loc_none)
[SMTPat (loc_includes s loc_none)] | let loc_includes_none = MG.loc_includes_none | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 838,
"start_col": 0,
"start_line": 838
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma
(ensures LowStar.Monotonic.Buffer.loc_includes s LowStar.Monotonic.Buffer.loc_none)
[SMTPat (LowStar.Monotonic.Buffer.loc_includes s LowStar.Monotonic.Buffer.loc_none)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_includes_none",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_includes_none =
| MG.loc_includes_none | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_refl | val loc_includes_refl
(s: loc)
: Lemma
(loc_includes s s)
[SMTPat (loc_includes s s)] | val loc_includes_refl
(s: loc)
: Lemma
(loc_includes s s)
[SMTPat (loc_includes s s)] | let loc_includes_refl = MG.loc_includes_refl | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 830,
"start_col": 0,
"start_line": 830
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma (ensures LowStar.Monotonic.Buffer.loc_includes s s)
[SMTPat (LowStar.Monotonic.Buffer.loc_includes s s)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_includes_refl",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_includes_refl =
| MG.loc_includes_refl | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_trans | val loc_includes_trans
(s1 s2 s3: loc)
: Lemma
(requires (loc_includes s1 s2 /\ loc_includes s2 s3))
(ensures (loc_includes s1 s3)) | val loc_includes_trans
(s1 s2 s3: loc)
: Lemma
(requires (loc_includes s1 s2 /\ loc_includes s2 s3))
(ensures (loc_includes s1 s3)) | let loc_includes_trans = MG.loc_includes_trans | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 46,
"end_line": 832,
"start_col": 0,
"start_line": 832
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s1: LowStar.Monotonic.Buffer.loc ->
s2: LowStar.Monotonic.Buffer.loc ->
s3: LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.loc_includes s1 s2 /\ LowStar.Monotonic.Buffer.loc_includes s2 s3)
(ensures LowStar.Monotonic.Buffer.loc_includes s1 s3) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_includes_trans",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_includes_trans =
| MG.loc_includes_trans | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_region_region | val loc_includes_region_region
(preserve_liveness1: bool)
(preserve_liveness2: bool)
(s1 s2: Set.set HS.rid)
: Lemma
(requires ((preserve_liveness1 ==> preserve_liveness2) /\ Set.subset s2 s1))
(ensures (loc_includes (loc_regions preserve_liveness1 s1) (loc_regions preserve_liveness2 s2)))
[SMTPat (loc_includes (loc_regions preserve_liveness1 s1) (loc_regions preserve_liveness2 s2))] | val loc_includes_region_region
(preserve_liveness1: bool)
(preserve_liveness2: bool)
(s1 s2: Set.set HS.rid)
: Lemma
(requires ((preserve_liveness1 ==> preserve_liveness2) /\ Set.subset s2 s1))
(ensures (loc_includes (loc_regions preserve_liveness1 s1) (loc_regions preserve_liveness2 s2)))
[SMTPat (loc_includes (loc_regions preserve_liveness1 s1) (loc_regions preserve_liveness2 s2))] | let loc_includes_region_region = MG.loc_includes_region_region #_ #cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 70,
"end_line": 892,
"start_col": 0,
"start_line": 892
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
preserve_liveness1: Prims.bool ->
preserve_liveness2: Prims.bool ->
s1: FStar.Set.set FStar.Monotonic.HyperHeap.rid ->
s2: FStar.Set.set FStar.Monotonic.HyperHeap.rid
-> FStar.Pervasives.Lemma
(requires (preserve_liveness1 ==> preserve_liveness2) /\ FStar.Set.subset s2 s1)
(ensures
LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_regions preserve_liveness1
s1)
(LowStar.Monotonic.Buffer.loc_regions preserve_liveness2 s2))
[
SMTPat (LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_regions preserve_liveness1
s1)
(LowStar.Monotonic.Buffer.loc_regions preserve_liveness2 s2))
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_includes_region_region",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_includes_region_region =
| MG.loc_includes_region_region #_ #cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_buffer | val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2))) | val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2))) | let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 104,
"end_line": 847,
"start_col": 0,
"start_line": 845
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b1: LowStar.Monotonic.Buffer.mbuffer a rrel1 rel1 ->
b2: LowStar.Monotonic.Buffer.mbuffer a rrel2 rel2
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.frameOf b1 == LowStar.Monotonic.Buffer.frameOf b2 /\
LowStar.Monotonic.Buffer.as_addr b1 == LowStar.Monotonic.Buffer.as_addr b2 /\
LowStar.Monotonic.Buffer.ubuffer_includes0 (LowStar.Monotonic.Buffer.ubuffer_of_buffer b1)
(LowStar.Monotonic.Buffer.ubuffer_of_buffer b2))
(ensures
LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_buffer b1)
(LowStar.Monotonic.Buffer.loc_buffer b2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.ModifiesGen.loc_includes_aloc",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer",
"Prims.unit"
] | [] | true | false | true | false | false | let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
| let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_
#cls
#(frameOf b1)
#(as_addr b1)
(ubuffer_of_buffer b1)
(ubuffer_of_buffer b2) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_union_r | val loc_includes_union_r
(s s1 s2: loc)
: Lemma
(requires (loc_includes s s1 /\ loc_includes s s2))
(ensures (loc_includes s (loc_union s1 s2))) | val loc_includes_union_r
(s s1 s2: loc)
: Lemma
(requires (loc_includes s s1 /\ loc_includes s s2))
(ensures (loc_includes s (loc_union s1 s2))) | let loc_includes_union_r = MG.loc_includes_union_r | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 834,
"start_col": 0,
"start_line": 834
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s: LowStar.Monotonic.Buffer.loc ->
s1: LowStar.Monotonic.Buffer.loc ->
s2: LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.loc_includes s s1 /\ LowStar.Monotonic.Buffer.loc_includes s s2)
(ensures LowStar.Monotonic.Buffer.loc_includes s (LowStar.Monotonic.Buffer.loc_union s1 s2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_includes_union_r",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_includes_union_r =
| MG.loc_includes_union_r | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies | val modifies
(s: loc)
(h1 h2: HS.mem)
: GTot Type0 | val modifies
(s: loc)
(h1 h2: HS.mem)
: GTot Type0 | let modifies = MG.modifies | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 928,
"start_col": 0,
"start_line": 928
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s: LowStar.Monotonic.Buffer.loc ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.ModifiesGen.modifies",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | false | false | false | false | true | let modifies =
| MG.modifies | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_region_addresses | val loc_includes_region_addresses
(preserve_liveness1: bool)
(preserve_liveness2: bool)
(s: Set.set HS.rid)
(r: HS.rid)
(a: Set.set nat)
: Lemma
(requires (Set.mem r s))
(ensures (loc_includes (loc_regions preserve_liveness1 s) (loc_addresses preserve_liveness2 r a)))
[SMTPat (loc_includes (loc_regions preserve_liveness1 s) (loc_addresses preserve_liveness2 r a))] | val loc_includes_region_addresses
(preserve_liveness1: bool)
(preserve_liveness2: bool)
(s: Set.set HS.rid)
(r: HS.rid)
(a: Set.set nat)
: Lemma
(requires (Set.mem r s))
(ensures (loc_includes (loc_regions preserve_liveness1 s) (loc_addresses preserve_liveness2 r a)))
[SMTPat (loc_includes (loc_regions preserve_liveness1 s) (loc_addresses preserve_liveness2 r a))] | let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 76,
"end_line": 890,
"start_col": 0,
"start_line": 890
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
preserve_liveness1: Prims.bool ->
preserve_liveness2: Prims.bool ->
s: FStar.Set.set FStar.Monotonic.HyperHeap.rid ->
r: FStar.Monotonic.HyperHeap.rid ->
a: FStar.Set.set Prims.nat
-> FStar.Pervasives.Lemma (requires FStar.Set.mem r s)
(ensures
LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_regions preserve_liveness1
s)
(LowStar.Monotonic.Buffer.loc_addresses preserve_liveness2 r a))
[
SMTPat (LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_regions preserve_liveness1
s)
(LowStar.Monotonic.Buffer.loc_addresses preserve_liveness2 r a))
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_includes_region_addresses",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_includes_region_addresses =
| MG.loc_includes_region_addresses #_ #cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_gsub_buffer_r | val loc_includes_gsub_buffer_r
(l:loc)
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (i:UInt32.t) (len:UInt32.t) (sub_rel:srel a)
: Lemma (requires (UInt32.v i + UInt32.v len <= (length b) /\
loc_includes l (loc_buffer b)))
(ensures (loc_includes l (loc_buffer (mgsub sub_rel b i len))))
[SMTPat (loc_includes l (loc_buffer (mgsub sub_rel b i len)))] | val loc_includes_gsub_buffer_r
(l:loc)
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (i:UInt32.t) (len:UInt32.t) (sub_rel:srel a)
: Lemma (requires (UInt32.v i + UInt32.v len <= (length b) /\
loc_includes l (loc_buffer b)))
(ensures (loc_includes l (loc_buffer (mgsub sub_rel b i len))))
[SMTPat (loc_includes l (loc_buffer (mgsub sub_rel b i len)))] | let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b') | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 852,
"start_col": 0,
"start_line": 849
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
l: LowStar.Monotonic.Buffer.loc ->
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
i: FStar.UInt32.t ->
len: FStar.UInt32.t ->
sub_rel: LowStar.Monotonic.Buffer.srel a
-> FStar.Pervasives.Lemma
(requires
FStar.UInt32.v i + FStar.UInt32.v len <= LowStar.Monotonic.Buffer.length b /\
LowStar.Monotonic.Buffer.loc_includes l (LowStar.Monotonic.Buffer.loc_buffer b))
(ensures
LowStar.Monotonic.Buffer.loc_includes l
(LowStar.Monotonic.Buffer.loc_buffer (LowStar.Monotonic.Buffer.mgsub sub_rel b i len)))
[
SMTPat (LowStar.Monotonic.Buffer.loc_includes l
(LowStar.Monotonic.Buffer.loc_buffer (LowStar.Monotonic.Buffer.mgsub sub_rel b i len))
)
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.loc",
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc_includes_trans",
"LowStar.Monotonic.Buffer.loc_buffer",
"Prims.unit",
"LowStar.Monotonic.Buffer.loc_includes_buffer",
"LowStar.Monotonic.Buffer.mgsub"
] | [] | true | false | true | false | false | let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
| let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b') | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_union_l | val loc_includes_union_l
(s1 s2 s: loc)
: Lemma
(requires (loc_includes s1 s \/ loc_includes s2 s))
(ensures (loc_includes (loc_union s1 s2) s)) | val loc_includes_union_l
(s1 s2 s: loc)
: Lemma
(requires (loc_includes s1 s \/ loc_includes s2 s))
(ensures (loc_includes (loc_union s1 s2) s)) | let loc_includes_union_l = MG.loc_includes_union_l | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 836,
"start_col": 0,
"start_line": 836
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s1: LowStar.Monotonic.Buffer.loc ->
s2: LowStar.Monotonic.Buffer.loc ->
s: LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.loc_includes s1 s \/ LowStar.Monotonic.Buffer.loc_includes s2 s)
(ensures LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_union s1 s2) s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_includes_union_l",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_includes_union_l =
| MG.loc_includes_union_l | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_disjoint_none_r | val loc_disjoint_none_r
(s: loc)
: Lemma
(ensures (loc_disjoint s loc_none))
[SMTPat (loc_disjoint s loc_none)] | val loc_disjoint_none_r
(s: loc)
: Lemma
(ensures (loc_disjoint s loc_none))
[SMTPat (loc_disjoint s loc_none)] | let loc_disjoint_none_r = MG.loc_disjoint_none_r | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 902,
"start_col": 0,
"start_line": 902
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma
(ensures LowStar.Monotonic.Buffer.loc_disjoint s LowStar.Monotonic.Buffer.loc_none)
[SMTPat (LowStar.Monotonic.Buffer.loc_disjoint s LowStar.Monotonic.Buffer.loc_none)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_disjoint_none_r",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_disjoint_none_r =
| MG.loc_disjoint_none_r | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_gsub_buffer_l | val loc_includes_gsub_buffer_l (#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(i1:UInt32.t) (len1:UInt32.t) (sub_rel1:srel a)
(i2:UInt32.t) (len2:UInt32.t) (sub_rel2:srel a)
:Lemma (requires (UInt32.v i1 + UInt32.v len1 <= (length b) /\
UInt32.v i1 <= UInt32.v i2 /\ UInt32.v i2 + UInt32.v len2 <= UInt32.v i1 + UInt32.v len1
))
(ensures (loc_includes (loc_buffer (mgsub sub_rel1 b i1 len1)) (loc_buffer (mgsub sub_rel2 b i2 len2))))
[SMTPat (mgsub sub_rel1 b i1 len1); SMTPat (mgsub sub_rel2 b i2 len2)] | val loc_includes_gsub_buffer_l (#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(i1:UInt32.t) (len1:UInt32.t) (sub_rel1:srel a)
(i2:UInt32.t) (len2:UInt32.t) (sub_rel2:srel a)
:Lemma (requires (UInt32.v i1 + UInt32.v len1 <= (length b) /\
UInt32.v i1 <= UInt32.v i2 /\ UInt32.v i2 + UInt32.v len2 <= UInt32.v i1 + UInt32.v len1
))
(ensures (loc_includes (loc_buffer (mgsub sub_rel1 b i1 len1)) (loc_buffer (mgsub sub_rel2 b i2 len2))))
[SMTPat (mgsub sub_rel1 b i1 len1); SMTPat (mgsub sub_rel2 b i2 len2)] | let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2 | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 857,
"start_col": 0,
"start_line": 854
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b') | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
i1: FStar.UInt32.t ->
len1: FStar.UInt32.t ->
sub_rel1: LowStar.Monotonic.Buffer.srel a ->
i2: FStar.UInt32.t ->
len2: FStar.UInt32.t ->
sub_rel2: LowStar.Monotonic.Buffer.srel a
-> FStar.Pervasives.Lemma
(requires
FStar.UInt32.v i1 + FStar.UInt32.v len1 <= LowStar.Monotonic.Buffer.length b /\
FStar.UInt32.v i1 <= FStar.UInt32.v i2 /\
FStar.UInt32.v i2 + FStar.UInt32.v len2 <= FStar.UInt32.v i1 + FStar.UInt32.v len1)
(ensures
LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_buffer (LowStar.Monotonic.Buffer.mgsub
sub_rel1
b
i1
len1))
(LowStar.Monotonic.Buffer.loc_buffer (LowStar.Monotonic.Buffer.mgsub sub_rel2 b i2 len2)))
[
SMTPat (LowStar.Monotonic.Buffer.mgsub sub_rel1 b i1 len1);
SMTPat (LowStar.Monotonic.Buffer.mgsub sub_rel2 b i2 len2)
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc_includes_buffer",
"LowStar.Monotonic.Buffer.mgsub",
"Prims.unit"
] | [] | true | false | true | false | false | let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
| let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2 | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_region_union_l | val loc_includes_region_union_l
(preserve_liveness: bool)
(l: loc)
(s1 s2: Set.set HS.rid)
: Lemma
(requires (loc_includes l (loc_regions preserve_liveness (Set.intersect s2 (Set.complement s1)))))
(ensures (loc_includes (loc_union (loc_regions preserve_liveness s1) l) (loc_regions preserve_liveness s2)))
[SMTPat (loc_includes (loc_union (loc_regions preserve_liveness s1) l) (loc_regions preserve_liveness s2))] | val loc_includes_region_union_l
(preserve_liveness: bool)
(l: loc)
(s1 s2: Set.set HS.rid)
: Lemma
(requires (loc_includes l (loc_regions preserve_liveness (Set.intersect s2 (Set.complement s1)))))
(ensures (loc_includes (loc_union (loc_regions preserve_liveness s1) l) (loc_regions preserve_liveness s2)))
[SMTPat (loc_includes (loc_union (loc_regions preserve_liveness s1) l) (loc_regions preserve_liveness s2))] | let loc_includes_region_union_l = MG.loc_includes_region_union_l | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 64,
"end_line": 894,
"start_col": 0,
"start_line": 894
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
preserve_liveness: Prims.bool ->
l: LowStar.Monotonic.Buffer.loc ->
s1: FStar.Set.set FStar.Monotonic.HyperHeap.rid ->
s2: FStar.Set.set FStar.Monotonic.HyperHeap.rid
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.loc_includes l
(LowStar.Monotonic.Buffer.loc_regions preserve_liveness
(FStar.Set.intersect s2 (FStar.Set.complement s1))))
(ensures
LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_union (LowStar.Monotonic.Buffer.loc_regions
preserve_liveness
s1)
l)
(LowStar.Monotonic.Buffer.loc_regions preserve_liveness s2))
[
SMTPat (LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_union (LowStar.Monotonic.Buffer.loc_regions
preserve_liveness
s1)
l)
(LowStar.Monotonic.Buffer.loc_regions preserve_liveness s2))
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_includes_region_union_l",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_includes_region_union_l =
| MG.loc_includes_region_union_l | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_as_seq | val loc_includes_as_seq (#a:Type0) (#rrel #rel1 #rel2:srel a)
(h1 h2:HS.mem) (larger:mbuffer a rrel rel1) (smaller:mbuffer a rrel rel2)
:Lemma (requires (loc_includes (loc_buffer larger) (loc_buffer smaller) /\
as_seq h1 larger == as_seq h2 larger /\
(live h1 larger \/ live h1 smaller) /\ (live h2 larger \/ live h2 smaller)))
(ensures (as_seq h1 smaller == as_seq h2 smaller)) | val loc_includes_as_seq (#a:Type0) (#rrel #rel1 #rel2:srel a)
(h1 h2:HS.mem) (larger:mbuffer a rrel rel1) (smaller:mbuffer a rrel rel2)
:Lemma (requires (loc_includes (loc_buffer larger) (loc_buffer smaller) /\
as_seq h1 larger == as_seq h2 larger /\
(live h1 larger \/ live h1 smaller) /\ (live h2 larger \/ live h2 smaller)))
(ensures (as_seq h1 smaller == as_seq h2 smaller)) | let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 881,
"start_col": 0,
"start_line": 870
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem ->
larger: LowStar.Monotonic.Buffer.mbuffer a rrel rel1 ->
smaller: LowStar.Monotonic.Buffer.mbuffer a rrel rel2
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_buffer larger)
(LowStar.Monotonic.Buffer.loc_buffer smaller) /\
LowStar.Monotonic.Buffer.as_seq h1 larger == LowStar.Monotonic.Buffer.as_seq h2 larger /\
(LowStar.Monotonic.Buffer.live h1 larger \/ LowStar.Monotonic.Buffer.live h1 smaller) /\
(LowStar.Monotonic.Buffer.live h2 larger \/ LowStar.Monotonic.Buffer.live h2 smaller))
(ensures
LowStar.Monotonic.Buffer.as_seq h1 smaller == LowStar.Monotonic.Buffer.as_seq h2 smaller) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Monotonic.Buffer.uu___is_Null",
"Prims.bool",
"FStar.ModifiesGen.loc_of_aloc_not_none",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer",
"Prims.unit",
"FStar.ModifiesGen.loc_includes_none_elim",
"LowStar.Monotonic.Buffer.loc_buffer",
"Prims._assert",
"Prims.eq2",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.as_seq",
"FStar.Seq.Base.slice",
"Prims.op_Subtraction",
"LowStar.Monotonic.Buffer.__proj__Mkubuffer___item__b_offset",
"Prims.op_Addition",
"LowStar.Monotonic.Buffer.length",
"LowStar.Monotonic.Buffer.ubuffer'",
"FStar.Ghost.reveal",
"FStar.ModifiesGen.loc_includes_aloc_elim"
] | [] | false | false | true | false | false | let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
| if Null? smaller
then ()
else
if Null? larger
then
(MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_
#cls
#(frameOf smaller)
#(as_addr smaller)
(ubuffer_of_buffer smaller))
else
(MG.loc_includes_aloc_elim #_
#cls
#(frameOf larger)
#(frameOf smaller)
#(as_addr larger)
#(as_addr smaller)
(ubuffer_of_buffer larger)
(ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller ==
Seq.slice (as_seq h1 larger)
(us.b_offset - ul.b_offset)
(us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller ==
Seq.slice (as_seq h2 larger)
(us.b_offset - ul.b_offset)
(us.b_offset - ul.b_offset + length smaller))) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.region_liveness_insensitive_locs | val region_liveness_insensitive_locs: loc | val region_liveness_insensitive_locs: loc | let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _ | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 76,
"end_line": 957,
"start_col": 0,
"start_line": 957
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _ | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | LowStar.Monotonic.Buffer.loc | Prims.Tot | [
"total"
] | [] | [
"FStar.ModifiesGen.region_liveness_insensitive_locs",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | false | false | false | true | false | let region_liveness_insensitive_locs =
| MG.region_liveness_insensitive_locs _ | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_region_buffer | val loc_includes_region_buffer (#a:Type0) (#rrel #rel:srel a)
(preserve_liveness:bool) (s:Set.set HS.rid) (b:mbuffer a rrel rel)
:Lemma (requires (Set.mem (frameOf b) s))
(ensures (loc_includes (loc_regions preserve_liveness s) (loc_buffer b)))
[SMTPat (loc_includes (loc_regions preserve_liveness s) (loc_buffer b))] | val loc_includes_region_buffer (#a:Type0) (#rrel #rel:srel a)
(preserve_liveness:bool) (s:Set.set HS.rid) (b:mbuffer a rrel rel)
:Lemma (requires (Set.mem (frameOf b) s))
(ensures (loc_includes (loc_regions preserve_liveness s) (loc_buffer b)))
[SMTPat (loc_includes (loc_regions preserve_liveness s) (loc_buffer b))] | let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 105,
"end_line": 888,
"start_col": 0,
"start_line": 887
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
preserve_liveness: Prims.bool ->
s: FStar.Set.set FStar.Monotonic.HyperHeap.rid ->
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel
-> FStar.Pervasives.Lemma (requires FStar.Set.mem (LowStar.Monotonic.Buffer.frameOf b) s)
(ensures
LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_regions preserve_liveness
s)
(LowStar.Monotonic.Buffer.loc_buffer b))
[
SMTPat (LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_regions preserve_liveness
s)
(LowStar.Monotonic.Buffer.loc_buffer b))
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"Prims.bool",
"FStar.Set.set",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.ModifiesGen.loc_includes_region_aloc",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer",
"Prims.unit"
] | [] | true | false | true | false | false | let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
| MG.loc_includes_region_aloc #_
#cls
preserve_liveness
s
#(frameOf b)
#(as_addr b)
(ubuffer_of_buffer b) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_loc_buffer_from_to | val loc_includes_loc_buffer_from_to
(#a: _) (#rrel #rel: _)
(b: mbuffer a rrel rel)
(from1 to1 from2 to2: U32.t)
: Lemma
(requires (U32.v from1 <= U32.v from2 /\ U32.v to2 <= U32.v to1))
(ensures (loc_includes (loc_buffer_from_to b from1 to1) (loc_buffer_from_to b from2 to2))) | val loc_includes_loc_buffer_from_to
(#a: _) (#rrel #rel: _)
(b: mbuffer a rrel rel)
(from1 to1 from2 to2: U32.t)
: Lemma
(requires (U32.v from1 <= U32.v from2 /\ U32.v to2 <= U32.v to1))
(ensures (loc_includes (loc_buffer_from_to b from1 to1) (loc_buffer_from_to b from2 to2))) | let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 141,
"end_line": 867,
"start_col": 0,
"start_line": 864
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
from1: FStar.UInt32.t ->
to1: FStar.UInt32.t ->
from2: FStar.UInt32.t ->
to2: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
FStar.UInt32.v from1 <= FStar.UInt32.v from2 /\ FStar.UInt32.v to2 <= FStar.UInt32.v to1)
(ensures
LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_buffer_from_to b
from1
to1)
(LowStar.Monotonic.Buffer.loc_buffer_from_to b from2 to2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"Prims.op_BarBar",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer_from_to_none_cond",
"Prims.bool",
"FStar.ModifiesGen.loc_includes_aloc",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer_from_to",
"Prims.unit"
] | [] | false | false | true | false | false | let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
| if
ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else
MG.loc_includes_aloc #_
#cls
#(frameOf b)
#(as_addr b)
(ubuffer_of_buffer_from_to b from1 to1)
(ubuffer_of_buffer_from_to b from2 to2) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.address_liveness_insensitive_locs | val address_liveness_insensitive_locs: loc | val address_liveness_insensitive_locs: loc | let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _ | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 78,
"end_line": 955,
"start_col": 0,
"start_line": 955
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | LowStar.Monotonic.Buffer.loc | Prims.Tot | [
"total"
] | [] | [
"FStar.ModifiesGen.address_liveness_insensitive_locs",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | false | false | false | true | false | let address_liveness_insensitive_locs =
| MG.address_liveness_insensitive_locs _ | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_loc_buffer_loc_buffer_from_to | val loc_includes_loc_buffer_loc_buffer_from_to
(#a: _) (#rrel #rel: _)
(b: mbuffer a rrel rel)
(from to: U32.t)
: Lemma
(loc_includes (loc_buffer b) (loc_buffer_from_to b from to)) | val loc_includes_loc_buffer_loc_buffer_from_to
(#a: _) (#rrel #rel: _)
(b: mbuffer a rrel rel)
(from to: U32.t)
: Lemma
(loc_includes (loc_buffer b) (loc_buffer_from_to b from to)) | let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 121,
"end_line": 862,
"start_col": 0,
"start_line": 859
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: LowStar.Monotonic.Buffer.mbuffer a rrel rel -> from: FStar.UInt32.t -> to: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(ensures
LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_buffer b)
(LowStar.Monotonic.Buffer.loc_buffer_from_to b from to)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer_from_to_none_cond",
"Prims.bool",
"FStar.ModifiesGen.loc_includes_aloc",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer_from_to",
"Prims.unit"
] | [] | false | false | true | false | false | let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
| if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else
MG.loc_includes_aloc #_
#cls
#(frameOf b)
#(as_addr b)
(ubuffer_of_buffer b)
(ubuffer_of_buffer_from_to b from to) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_addresses_addresses | val loc_includes_addresses_addresses
(preserve_liveness1 preserve_liveness2: bool)
(r: HS.rid)
(s1 s2: Set.set nat)
: Lemma
(requires ((preserve_liveness1 ==> preserve_liveness2) /\ Set.subset s2 s1))
(ensures (loc_includes (loc_addresses preserve_liveness1 r s1) (loc_addresses preserve_liveness2 r s2))) | val loc_includes_addresses_addresses
(preserve_liveness1 preserve_liveness2: bool)
(r: HS.rid)
(s1 s2: Set.set nat)
: Lemma
(requires ((preserve_liveness1 ==> preserve_liveness2) /\ Set.subset s2 s1))
(ensures (loc_includes (loc_addresses preserve_liveness1 r s1) (loc_addresses preserve_liveness2 r s2))) | let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 78,
"end_line": 896,
"start_col": 0,
"start_line": 896
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
preserve_liveness1: Prims.bool ->
preserve_liveness2: Prims.bool ->
r: FStar.Monotonic.HyperHeap.rid ->
s1: FStar.Set.set Prims.nat ->
s2: FStar.Set.set Prims.nat
-> FStar.Pervasives.Lemma
(requires (preserve_liveness1 ==> preserve_liveness2) /\ FStar.Set.subset s2 s1)
(ensures
LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_addresses preserve_liveness1
r
s1)
(LowStar.Monotonic.Buffer.loc_addresses preserve_liveness2 r s2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_includes_addresses_addresses",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_includes_addresses_addresses =
| MG.loc_includes_addresses_addresses cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_disjoint_sym | val loc_disjoint_sym
(s1 s2: loc)
: Lemma
(requires (loc_disjoint s1 s2))
(ensures (loc_disjoint s2 s1)) | val loc_disjoint_sym
(s1 s2: loc)
: Lemma
(requires (loc_disjoint s1 s2))
(ensures (loc_disjoint s2 s1)) | let loc_disjoint_sym = MG.loc_disjoint_sym | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 900,
"start_col": 0,
"start_line": 900
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s1: LowStar.Monotonic.Buffer.loc -> s2: LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma (requires LowStar.Monotonic.Buffer.loc_disjoint s1 s2)
(ensures LowStar.Monotonic.Buffer.loc_disjoint s2 s1) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_disjoint_sym",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_disjoint_sym =
| MG.loc_disjoint_sym | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_disjoint_buffer | val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2))) | val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2))) | let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 138,
"end_line": 914,
"start_col": 0,
"start_line": 913
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b1: LowStar.Monotonic.Buffer.mbuffer a1 rrel1 rel1 ->
b2: LowStar.Monotonic.Buffer.mbuffer a2 rrel2 rel2
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.frameOf b1 == LowStar.Monotonic.Buffer.frameOf b2 /\
LowStar.Monotonic.Buffer.as_addr b1 == LowStar.Monotonic.Buffer.as_addr b2 ==>
LowStar.Monotonic.Buffer.ubuffer_disjoint0 (LowStar.Monotonic.Buffer.ubuffer_of_buffer b1)
(LowStar.Monotonic.Buffer.ubuffer_of_buffer b2))
(ensures
LowStar.Monotonic.Buffer.loc_disjoint (LowStar.Monotonic.Buffer.loc_buffer b1)
(LowStar.Monotonic.Buffer.loc_buffer b2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.ModifiesGen.loc_disjoint_aloc_intro",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer",
"Prims.unit"
] | [] | true | false | true | false | false | let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
| MG.loc_disjoint_aloc_intro #_
#cls
#(frameOf b1)
#(as_addr b1)
#(frameOf b2)
#(as_addr b2)
(ubuffer_of_buffer b1)
(ubuffer_of_buffer b2) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_includes_addresses_buffer | val loc_includes_addresses_buffer (#a:Type0) (#rrel #rel:srel a)
(preserve_liveness:bool) (r:HS.rid) (s:Set.set nat) (p:mbuffer a rrel rel)
:Lemma (requires (frameOf p == r /\ Set.mem (as_addr p) s))
(ensures (loc_includes (loc_addresses preserve_liveness r s) (loc_buffer p)))
[SMTPat (loc_includes (loc_addresses preserve_liveness r s) (loc_buffer p))] | val loc_includes_addresses_buffer (#a:Type0) (#rrel #rel:srel a)
(preserve_liveness:bool) (r:HS.rid) (s:Set.set nat) (p:mbuffer a rrel rel)
:Lemma (requires (frameOf p == r /\ Set.mem (as_addr p) s))
(ensures (loc_includes (loc_addresses preserve_liveness r s) (loc_buffer p)))
[SMTPat (loc_includes (loc_addresses preserve_liveness r s) (loc_buffer p))] | let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 97,
"end_line": 885,
"start_col": 0,
"start_line": 884
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
preserve_liveness: Prims.bool ->
r: FStar.Monotonic.HyperHeap.rid ->
s: FStar.Set.set Prims.nat ->
p: LowStar.Monotonic.Buffer.mbuffer a rrel rel
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.frameOf p == r /\
FStar.Set.mem (LowStar.Monotonic.Buffer.as_addr p) s)
(ensures
LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_addresses preserve_liveness
r
s)
(LowStar.Monotonic.Buffer.loc_buffer p))
[
SMTPat (LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_addresses preserve_liveness
r
s)
(LowStar.Monotonic.Buffer.loc_buffer p))
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"Prims.bool",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Set.set",
"Prims.nat",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.ModifiesGen.loc_includes_addresses_aloc",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer",
"Prims.unit"
] | [] | true | false | true | false | false | let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
| MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_disjoint_union_r | val loc_disjoint_union_r
(s s1 s2: loc)
: Lemma
(requires (loc_disjoint s s1 /\ loc_disjoint s s2))
(ensures (loc_disjoint s (loc_union s1 s2))) | val loc_disjoint_union_r
(s s1 s2: loc)
: Lemma
(requires (loc_disjoint s s1 /\ loc_disjoint s s2))
(ensures (loc_disjoint s (loc_union s1 s2))) | let loc_disjoint_union_r = MG.loc_disjoint_union_r | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 904,
"start_col": 0,
"start_line": 904
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s: LowStar.Monotonic.Buffer.loc ->
s1: LowStar.Monotonic.Buffer.loc ->
s2: LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.loc_disjoint s s1 /\ LowStar.Monotonic.Buffer.loc_disjoint s s2)
(ensures LowStar.Monotonic.Buffer.loc_disjoint s (LowStar.Monotonic.Buffer.loc_union s1 s2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_disjoint_union_r",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_disjoint_union_r =
| MG.loc_disjoint_union_r | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_disjoint_addresses | val loc_disjoint_addresses
(preserve_liveness1 preserve_liveness2: bool)
(r1 r2: HS.rid)
(n1 n2: Set.set nat)
: Lemma
(requires (r1 <> r2 \/ Set.subset (Set.intersect n1 n2) Set.empty))
(ensures (loc_disjoint (loc_addresses preserve_liveness1 r1 n1) (loc_addresses preserve_liveness2 r2 n2)))
[SMTPat (loc_disjoint (loc_addresses preserve_liveness1 r1 n1) (loc_addresses preserve_liveness2 r2 n2))] | val loc_disjoint_addresses
(preserve_liveness1 preserve_liveness2: bool)
(r1 r2: HS.rid)
(n1 n2: Set.set nat)
: Lemma
(requires (r1 <> r2 \/ Set.subset (Set.intersect n1 n2) Set.empty))
(ensures (loc_disjoint (loc_addresses preserve_liveness1 r1 n1) (loc_addresses preserve_liveness2 r2 n2)))
[SMTPat (loc_disjoint (loc_addresses preserve_liveness1 r1 n1) (loc_addresses preserve_liveness2 r2 n2))] | let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 68,
"end_line": 924,
"start_col": 0,
"start_line": 924
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
preserve_liveness1: Prims.bool ->
preserve_liveness2: Prims.bool ->
r1: FStar.Monotonic.HyperHeap.rid ->
r2: FStar.Monotonic.HyperHeap.rid ->
n1: FStar.Set.set Prims.nat ->
n2: FStar.Set.set Prims.nat
-> FStar.Pervasives.Lemma
(requires r1 <> r2 \/ FStar.Set.subset (FStar.Set.intersect n1 n2) FStar.Set.empty)
(ensures
LowStar.Monotonic.Buffer.loc_disjoint (LowStar.Monotonic.Buffer.loc_addresses preserve_liveness1
r1
n1)
(LowStar.Monotonic.Buffer.loc_addresses preserve_liveness2 r2 n2))
[
SMTPat (LowStar.Monotonic.Buffer.loc_disjoint (LowStar.Monotonic.Buffer.loc_addresses preserve_liveness1
r1
n1)
(LowStar.Monotonic.Buffer.loc_addresses preserve_liveness2 r2 n2))
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_disjoint_addresses_intro",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_disjoint_addresses =
| MG.loc_disjoint_addresses_intro #_ #cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_loc_includes | val modifies_loc_includes
(s1: loc)
(h h': HS.mem)
(s2: loc)
: Lemma
(requires (modifies s2 h h' /\ loc_includes s1 s2))
(ensures (modifies s1 h h'))
[SMTPat (modifies s1 h h'); SMTPat (modifies s2 h h')] | val modifies_loc_includes
(s1: loc)
(h h': HS.mem)
(s2: loc)
: Lemma
(requires (modifies s2 h h' /\ loc_includes s1 s2))
(ensures (modifies s1 h h'))
[SMTPat (modifies s1 h h'); SMTPat (modifies s2 h h')] | let modifies_loc_includes = MG.modifies_loc_includes | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 52,
"end_line": 953,
"start_col": 0,
"start_line": 953
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s1: LowStar.Monotonic.Buffer.loc ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem ->
s2: LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.modifies s2 h h' /\ LowStar.Monotonic.Buffer.loc_includes s1 s2)
(ensures LowStar.Monotonic.Buffer.modifies s1 h h')
[
SMTPat (LowStar.Monotonic.Buffer.modifies s1 h h');
SMTPat (LowStar.Monotonic.Buffer.modifies s2 h h')
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_loc_includes",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_loc_includes =
| MG.modifies_loc_includes | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_mreference_elim | val modifies_mreference_elim
(#t: Type)
(#pre: Preorder.preorder t)
(b: HS.mreference t pre)
(p: loc)
(h h': HS.mem)
: Lemma
(requires (
loc_disjoint (loc_mreference b) p /\
HS.contains h b /\
modifies p h h'
))
(ensures (
HS.contains h' b /\
HS.sel h b == HS.sel h' b
))
[SMTPatOr [
[ SMTPat (modifies p h h'); SMTPat (HS.sel h b) ] ;
[ SMTPat (modifies p h h'); SMTPat (HS.contains h b) ];
[ SMTPat (modifies p h h'); SMTPat (HS.sel h' b) ] ;
[ SMTPat (modifies p h h'); SMTPat (HS.contains h' b) ]
] ] | val modifies_mreference_elim
(#t: Type)
(#pre: Preorder.preorder t)
(b: HS.mreference t pre)
(p: loc)
(h h': HS.mem)
: Lemma
(requires (
loc_disjoint (loc_mreference b) p /\
HS.contains h b /\
modifies p h h'
))
(ensures (
HS.contains h' b /\
HS.sel h b == HS.sel h' b
))
[SMTPatOr [
[ SMTPat (modifies p h h'); SMTPat (HS.sel h b) ] ;
[ SMTPat (modifies p h h'); SMTPat (HS.contains h b) ];
[ SMTPat (modifies p h h'); SMTPat (HS.sel h' b) ] ;
[ SMTPat (modifies p h h'); SMTPat (HS.contains h' b) ]
] ] | let modifies_mreference_elim = MG.modifies_mreference_elim | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 58,
"end_line": 932,
"start_col": 0,
"start_line": 932
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: FStar.Monotonic.HyperStack.mreference t pre ->
p: LowStar.Monotonic.Buffer.loc ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.loc_disjoint (LowStar.Monotonic.Buffer.loc_mreference b) p /\
FStar.Monotonic.HyperStack.contains h b /\ LowStar.Monotonic.Buffer.modifies p h h')
(ensures
FStar.Monotonic.HyperStack.contains h' b /\
FStar.Monotonic.HyperStack.sel h b == FStar.Monotonic.HyperStack.sel h' b)
[
SMTPatOr [
[
SMTPat (LowStar.Monotonic.Buffer.modifies p h h');
SMTPat (FStar.Monotonic.HyperStack.sel h b)
];
[
SMTPat (LowStar.Monotonic.Buffer.modifies p h h');
SMTPat (FStar.Monotonic.HyperStack.contains h b)
];
[
SMTPat (LowStar.Monotonic.Buffer.modifies p h h');
SMTPat (FStar.Monotonic.HyperStack.sel h' b)
];
[
SMTPat (LowStar.Monotonic.Buffer.modifies p h h');
SMTPat (FStar.Monotonic.HyperStack.contains h' b)
]
]
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_mreference_elim",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_mreference_elim =
| MG.modifies_mreference_elim | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_disjoint_includes | val loc_disjoint_includes
(p1 p2 p1' p2' : loc)
: Lemma
(requires (loc_includes p1 p1' /\ loc_includes p2 p2' /\ loc_disjoint p1 p2))
(ensures (loc_disjoint p1' p2')) | val loc_disjoint_includes
(p1 p2 p1' p2' : loc)
: Lemma
(requires (loc_includes p1 p1' /\ loc_includes p2 p2' /\ loc_disjoint p1 p2))
(ensures (loc_disjoint p1' p2')) | let loc_disjoint_includes = MG.loc_disjoint_includes | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 52,
"end_line": 906,
"start_col": 0,
"start_line": 906
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p1: LowStar.Monotonic.Buffer.loc ->
p2: LowStar.Monotonic.Buffer.loc ->
p1': LowStar.Monotonic.Buffer.loc ->
p2': LowStar.Monotonic.Buffer.loc
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.loc_includes p1 p1' /\ LowStar.Monotonic.Buffer.loc_includes p2 p2' /\
LowStar.Monotonic.Buffer.loc_disjoint p1 p2)
(ensures LowStar.Monotonic.Buffer.loc_disjoint p1' p2') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_disjoint_includes",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_disjoint_includes =
| MG.loc_disjoint_includes | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_live_region | val modifies_live_region
(s: loc)
(h1 h2: HS.mem)
(r: HS.rid)
: Lemma
(requires (modifies s h1 h2 /\ loc_disjoint s (loc_region_only false r) /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
[SMTPatOr [
[SMTPat (modifies s h1 h2); SMTPat (HS.live_region h1 r)];
[SMTPat (modifies s h1 h2); SMTPat (HS.live_region h2 r)];
]] | val modifies_live_region
(s: loc)
(h1 h2: HS.mem)
(r: HS.rid)
: Lemma
(requires (modifies s h1 h2 /\ loc_disjoint s (loc_region_only false r) /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
[SMTPatOr [
[SMTPat (modifies s h1 h2); SMTPat (HS.live_region h1 r)];
[SMTPat (modifies s h1 h2); SMTPat (HS.live_region h2 r)];
]] | let modifies_live_region = MG.modifies_live_region | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 930,
"start_col": 0,
"start_line": 930
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s: LowStar.Monotonic.Buffer.loc ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem ->
r: FStar.Monotonic.HyperHeap.rid
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.modifies s h1 h2 /\
LowStar.Monotonic.Buffer.loc_disjoint s (LowStar.Monotonic.Buffer.loc_region_only false r) /\
FStar.Monotonic.HyperStack.live_region h1 r)
(ensures FStar.Monotonic.HyperStack.live_region h2 r)
[
SMTPatOr [
[
SMTPat (LowStar.Monotonic.Buffer.modifies s h1 h2);
SMTPat (FStar.Monotonic.HyperStack.live_region h1 r)
];
[
SMTPat (LowStar.Monotonic.Buffer.modifies s h1 h2);
SMTPat (FStar.Monotonic.HyperStack.live_region h2 r)
]
]
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_live_region",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_live_region =
| MG.modifies_live_region | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_disjoint_regions | val loc_disjoint_regions
(preserve_liveness1: bool)
(preserve_liveness2: bool)
(rs1 rs2: Set.set HS.rid)
: Lemma
(requires (Set.subset (Set.intersect rs1 rs2) Set.empty))
(ensures (loc_disjoint (loc_regions preserve_liveness1 rs1) (loc_regions preserve_liveness2 rs2)))
[SMTPat (loc_disjoint (loc_regions preserve_liveness1 rs1) (loc_regions preserve_liveness2 rs2))] | val loc_disjoint_regions
(preserve_liveness1: bool)
(preserve_liveness2: bool)
(rs1 rs2: Set.set HS.rid)
: Lemma
(requires (Set.subset (Set.intersect rs1 rs2) Set.empty))
(ensures (loc_disjoint (loc_regions preserve_liveness1 rs1) (loc_regions preserve_liveness2 rs2)))
[SMTPat (loc_disjoint (loc_regions preserve_liveness1 rs1) (loc_regions preserve_liveness2 rs2))] | let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 58,
"end_line": 926,
"start_col": 0,
"start_line": 926
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
preserve_liveness1: Prims.bool ->
preserve_liveness2: Prims.bool ->
rs1: FStar.Set.set FStar.Monotonic.HyperHeap.rid ->
rs2: FStar.Set.set FStar.Monotonic.HyperHeap.rid
-> FStar.Pervasives.Lemma
(requires FStar.Set.subset (FStar.Set.intersect rs1 rs2) FStar.Set.empty)
(ensures
LowStar.Monotonic.Buffer.loc_disjoint (LowStar.Monotonic.Buffer.loc_regions preserve_liveness1
rs1)
(LowStar.Monotonic.Buffer.loc_regions preserve_liveness2 rs2))
[
SMTPat (LowStar.Monotonic.Buffer.loc_disjoint (LowStar.Monotonic.Buffer.loc_regions preserve_liveness1
rs1)
(LowStar.Monotonic.Buffer.loc_regions preserve_liveness2 rs2))
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_disjoint_regions",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_disjoint_regions =
| MG.loc_disjoint_regions #_ #cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_buffer_elim | val modifies_buffer_elim (#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (p:loc) (h h':HS.mem)
:Lemma (requires (loc_disjoint (loc_buffer b) p /\ live h b /\ modifies p h h'))
(ensures (live h' b /\ (as_seq h b == as_seq h' b)))
[SMTPatOr [
[ SMTPat (modifies p h h'); SMTPat (as_seq h b) ] ;
[ SMTPat (modifies p h h'); SMTPat (live h b) ];
[ SMTPat (modifies p h h'); SMTPat (as_seq h' b) ] ;
[ SMTPat (modifies p h h'); SMTPat (live h' b) ]
]] | val modifies_buffer_elim (#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (p:loc) (h h':HS.mem)
:Lemma (requires (loc_disjoint (loc_buffer b) p /\ live h b /\ modifies p h h'))
(ensures (live h' b /\ (as_seq h b == as_seq h' b)))
[SMTPatOr [
[ SMTPat (modifies p h h'); SMTPat (as_seq h b) ] ;
[ SMTPat (modifies p h h'); SMTPat (live h b) ];
[ SMTPat (modifies p h h'); SMTPat (as_seq h' b) ] ;
[ SMTPat (modifies p h h'); SMTPat (live h' b) ]
]] | let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 941,
"start_col": 0,
"start_line": 934
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
p: LowStar.Monotonic.Buffer.loc ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.loc_disjoint (LowStar.Monotonic.Buffer.loc_buffer b) p /\
LowStar.Monotonic.Buffer.live h b /\ LowStar.Monotonic.Buffer.modifies p h h')
(ensures
LowStar.Monotonic.Buffer.live h' b /\
LowStar.Monotonic.Buffer.as_seq h b == LowStar.Monotonic.Buffer.as_seq h' b)
[
SMTPatOr [
[
SMTPat (LowStar.Monotonic.Buffer.modifies p h h');
SMTPat (LowStar.Monotonic.Buffer.as_seq h b)
];
[
SMTPat (LowStar.Monotonic.Buffer.modifies p h h');
SMTPat (LowStar.Monotonic.Buffer.live h b)
];
[
SMTPat (LowStar.Monotonic.Buffer.modifies p h h');
SMTPat (LowStar.Monotonic.Buffer.as_seq h' b)
];
[
SMTPat (LowStar.Monotonic.Buffer.modifies p h h');
SMTPat (LowStar.Monotonic.Buffer.live h' b)
]
]
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Monotonic.Buffer.loc",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.g_is_null",
"Prims._assert",
"FStar.Seq.Base.equal",
"LowStar.Monotonic.Buffer.as_seq",
"Prims.bool",
"LowStar.Monotonic.Buffer.ubuffer_preserved_elim",
"Prims.unit",
"FStar.ModifiesGen.modifies_aloc_elim",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer"
] | [] | false | false | true | false | false | let modifies_buffer_elim #_ #_ #_ b p h h' =
| if g_is_null b
then assert ((as_seq h b) `Seq.equal` (as_seq h' b))
else
(MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h';
ubuffer_preserved_elim b h h') | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_disjoint_loc_buffer_from_to | val loc_disjoint_loc_buffer_from_to
(#a: _) (#rrel #rel: _)
(b: mbuffer a rrel rel)
(from1 to1 from2 to2: U32.t)
: Lemma
(requires (U32.v to1 <= U32.v from2 \/ U32.v to2 <= U32.v from1))
(ensures (loc_disjoint (loc_buffer_from_to b from1 to1) (loc_buffer_from_to b from2 to2))) | val loc_disjoint_loc_buffer_from_to
(#a: _) (#rrel #rel: _)
(b: mbuffer a rrel rel)
(from1 to1 from2 to2: U32.t)
: Lemma
(requires (U32.v to1 <= U32.v from2 \/ U32.v to2 <= U32.v from1))
(ensures (loc_disjoint (loc_buffer_from_to b from1 to1) (loc_buffer_from_to b from2 to2))) | let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 173,
"end_line": 922,
"start_col": 0,
"start_line": 919
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
from1: FStar.UInt32.t ->
to1: FStar.UInt32.t ->
from2: FStar.UInt32.t ->
to2: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
FStar.UInt32.v to1 <= FStar.UInt32.v from2 \/ FStar.UInt32.v to2 <= FStar.UInt32.v from1)
(ensures
LowStar.Monotonic.Buffer.loc_disjoint (LowStar.Monotonic.Buffer.loc_buffer_from_to b
from1
to1)
(LowStar.Monotonic.Buffer.loc_buffer_from_to b from2 to2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"Prims.op_BarBar",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer_from_to_none_cond",
"Prims.bool",
"FStar.ModifiesGen.loc_disjoint_aloc_intro",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer_from_to",
"Prims.unit"
] | [] | false | false | true | false | false | let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
| if
ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else
MG.loc_disjoint_aloc_intro #_
#cls
#(frameOf b)
#(as_addr b)
#(frameOf b)
#(as_addr b)
(ubuffer_of_buffer_from_to b from1 to1)
(ubuffer_of_buffer_from_to b from2 to2) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.address_liveness_insensitive_buffer | val address_liveness_insensitive_buffer (#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
:Lemma (address_liveness_insensitive_locs `loc_includes` (loc_buffer b))
[SMTPat (address_liveness_insensitive_locs `loc_includes` (loc_buffer b))] | val address_liveness_insensitive_buffer (#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
:Lemma (address_liveness_insensitive_locs `loc_includes` (loc_buffer b))
[SMTPat (address_liveness_insensitive_locs `loc_includes` (loc_buffer b))] | let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 112,
"end_line": 960,
"start_col": 0,
"start_line": 959
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _ | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: LowStar.Monotonic.Buffer.mbuffer a rrel rel
-> FStar.Pervasives.Lemma
(ensures
LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.address_liveness_insensitive_locs
(LowStar.Monotonic.Buffer.loc_buffer b))
[
SMTPat (LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.address_liveness_insensitive_locs
(LowStar.Monotonic.Buffer.loc_buffer b))
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.ModifiesGen.loc_includes_address_liveness_insensitive_locs_aloc",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer",
"Prims.unit"
] | [] | true | false | true | false | false | let address_liveness_insensitive_buffer #_ #_ #_ b =
| MG.loc_includes_address_liveness_insensitive_locs_aloc #_
#cls
#(frameOf b)
#(as_addr b)
(ubuffer_of_buffer b) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_buffer_from_to_elim | val modifies_buffer_from_to_elim (#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (p:loc) (h h':HS.mem)
:Lemma (requires (loc_disjoint (loc_buffer_from_to b from to) p /\ live h b /\ modifies p h h' /\ U32.v from <= U32.v to /\ U32.v to <= length b))
(ensures (live h' b /\ Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))) | val modifies_buffer_from_to_elim (#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (p:loc) (h h':HS.mem)
:Lemma (requires (loc_disjoint (loc_buffer_from_to b from to) p /\ live h b /\ modifies p h h' /\ U32.v from <= U32.v to /\ U32.v to <= length b))
(ensures (live h' b /\ Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))) | let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 949,
"start_col": 0,
"start_line": 943
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
from: FStar.UInt32.t ->
to: FStar.UInt32.t ->
p: LowStar.Monotonic.Buffer.loc ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.loc_disjoint (LowStar.Monotonic.Buffer.loc_buffer_from_to b from to
)
p /\ LowStar.Monotonic.Buffer.live h b /\ LowStar.Monotonic.Buffer.modifies p h h' /\
FStar.UInt32.v from <= FStar.UInt32.v to /\
FStar.UInt32.v to <= LowStar.Monotonic.Buffer.length b)
(ensures
LowStar.Monotonic.Buffer.live h' b /\
FStar.Seq.Base.slice (LowStar.Monotonic.Buffer.as_seq h b)
(FStar.UInt32.v from)
(FStar.UInt32.v to) ==
FStar.Seq.Base.slice (LowStar.Monotonic.Buffer.as_seq h' b)
(FStar.UInt32.v from)
(FStar.UInt32.v to)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.g_is_null",
"Prims.bool",
"LowStar.Monotonic.Buffer.ubuffer_preserved_from_to_elim",
"Prims.unit",
"FStar.ModifiesGen.modifies_aloc_elim",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer_from_to"
] | [] | false | false | true | false | false | let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
| if g_is_null b
then ()
else
(MG.modifies_aloc_elim #_
#cls
#(frameOf b)
#(as_addr b)
(ubuffer_of_buffer_from_to b from to)
p
h
h';
ubuffer_preserved_from_to_elim b from to h h') | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_trans | val modifies_trans
(s12: loc)
(h1 h2: HS.mem)
(s23: loc)
(h3: HS.mem)
: Lemma
(requires (modifies s12 h1 h2 /\ modifies s23 h2 h3))
(ensures (modifies (loc_union s12 s23) h1 h3)) | val modifies_trans
(s12: loc)
(h1 h2: HS.mem)
(s23: loc)
(h3: HS.mem)
: Lemma
(requires (modifies s12 h1 h2 /\ modifies s23 h2 h3))
(ensures (modifies (loc_union s12 s23) h1 h3)) | let modifies_trans = MG.modifies_trans | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 993,
"start_col": 0,
"start_line": 993
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s12: LowStar.Monotonic.Buffer.loc ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem ->
s23: LowStar.Monotonic.Buffer.loc ->
h3: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.modifies s12 h1 h2 /\ LowStar.Monotonic.Buffer.modifies s23 h2 h3)
(ensures LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union s12 s23) h1 h3) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_trans",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_trans =
| MG.modifies_trans | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_refl | val modifies_refl
(s: loc)
(h: HS.mem)
: Lemma
(modifies s h h)
[SMTPat (modifies s h h)] | val modifies_refl
(s: loc)
(h: HS.mem)
: Lemma
(modifies s h h)
[SMTPat (modifies s h h)] | let modifies_refl = MG.modifies_refl | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 951,
"start_col": 0,
"start_line": 951
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: LowStar.Monotonic.Buffer.loc -> h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (ensures LowStar.Monotonic.Buffer.modifies s h h)
[SMTPat (LowStar.Monotonic.Buffer.modifies s h h)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_refl",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_refl =
| MG.modifies_refl | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_liveness_insensitive_region | val modifies_liveness_insensitive_region
(l1 l2 : loc)
(h h' : HS.mem)
(x: HS.rid)
: Lemma
(requires (modifies (loc_union l1 l2) h h' /\ loc_disjoint l1 (loc_region_only false x) /\ region_liveness_insensitive_locs `loc_includes` l2 /\ HS.live_region h x))
(ensures (HS.live_region h' x))
[SMTPatOr [
[SMTPat (modifies (loc_union l1 l2) h h'); SMTPat (HS.live_region h x)];
[SMTPat (modifies (loc_union l1 l2) h h'); SMTPat (HS.live_region h' x)];
]] | val modifies_liveness_insensitive_region
(l1 l2 : loc)
(h h' : HS.mem)
(x: HS.rid)
: Lemma
(requires (modifies (loc_union l1 l2) h h' /\ loc_disjoint l1 (loc_region_only false x) /\ region_liveness_insensitive_locs `loc_includes` l2 /\ HS.live_region h x))
(ensures (HS.live_region h' x))
[SMTPatOr [
[SMTPat (modifies (loc_union l1 l2) h h'); SMTPat (HS.live_region h x)];
[SMTPat (modifies (loc_union l1 l2) h h'); SMTPat (HS.live_region h' x)];
]] | let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 80,
"end_line": 985,
"start_col": 0,
"start_line": 985
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
l1: LowStar.Monotonic.Buffer.loc ->
l2: LowStar.Monotonic.Buffer.loc ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem ->
x: FStar.Monotonic.HyperHeap.rid
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2) h h' /\
LowStar.Monotonic.Buffer.loc_disjoint l1 (LowStar.Monotonic.Buffer.loc_region_only false x) /\
LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.region_liveness_insensitive_locs
l2 /\ FStar.Monotonic.HyperStack.live_region h x)
(ensures FStar.Monotonic.HyperStack.live_region h' x)
[
SMTPatOr [
[
SMTPat (LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2)
h
h');
SMTPat (FStar.Monotonic.HyperStack.live_region h x)
];
[
SMTPat (LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2)
h
h');
SMTPat (FStar.Monotonic.HyperStack.live_region h' x)
]
]
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_preserves_region_liveness",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_liveness_insensitive_region =
| MG.modifies_preserves_region_liveness | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.does_not_contain_addr | val does_not_contain_addr
(h: HS.mem)
(ra: HS.rid * nat)
: GTot Type0 | val does_not_contain_addr
(h: HS.mem)
(ra: HS.rid * nat)
: GTot Type0 | let does_not_contain_addr = MG.does_not_contain_addr | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 52,
"end_line": 1197,
"start_col": 0,
"start_line": 1197
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options
let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h: FStar.Monotonic.HyperStack.mem -> ra: (FStar.Monotonic.HyperHeap.rid * Prims.nat)
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.ModifiesGen.does_not_contain_addr"
] | [] | false | false | false | false | true | let does_not_contain_addr =
| MG.does_not_contain_addr | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_liveness_insensitive_mreference | val modifies_liveness_insensitive_mreference
(l1 l2 : loc)
(h h' : HS.mem)
(#t: Type)
(#pre: Preorder.preorder t)
(x: HS.mreference t pre)
: Lemma
(requires (modifies (loc_union l1 l2) h h' /\ loc_disjoint l1 (loc_mreference x) /\ address_liveness_insensitive_locs `loc_includes` l2 /\ h `HS.contains` x))
(ensures (h' `HS.contains` x))
[SMTPatOr [
[SMTPat (h `HS.contains` x); SMTPat (modifies (loc_union l1 l2) h h');];
[SMTPat (h' `HS.contains` x); SMTPat (modifies (loc_union l1 l2) h h');];
]] | val modifies_liveness_insensitive_mreference
(l1 l2 : loc)
(h h' : HS.mem)
(#t: Type)
(#pre: Preorder.preorder t)
(x: HS.mreference t pre)
: Lemma
(requires (modifies (loc_union l1 l2) h h' /\ loc_disjoint l1 (loc_mreference x) /\ address_liveness_insensitive_locs `loc_includes` l2 /\ h `HS.contains` x))
(ensures (h' `HS.contains` x))
[SMTPatOr [
[SMTPat (h `HS.contains` x); SMTPat (modifies (loc_union l1 l2) h h');];
[SMTPat (h' `HS.contains` x); SMTPat (modifies (loc_union l1 l2) h h');];
]] | let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 77,
"end_line": 977,
"start_col": 0,
"start_line": 977
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
l1: LowStar.Monotonic.Buffer.loc ->
l2: LowStar.Monotonic.Buffer.loc ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem ->
x: FStar.Monotonic.HyperStack.mreference t pre
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2) h h' /\
LowStar.Monotonic.Buffer.loc_disjoint l1 (LowStar.Monotonic.Buffer.loc_mreference x) /\
LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.address_liveness_insensitive_locs
l2 /\ FStar.Monotonic.HyperStack.contains h x)
(ensures FStar.Monotonic.HyperStack.contains h' x)
[
SMTPatOr [
[
SMTPat (FStar.Monotonic.HyperStack.contains h x);
SMTPat (LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2)
h
h')
];
[
SMTPat (FStar.Monotonic.HyperStack.contains h' x);
SMTPat (LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2)
h
h')
]
]
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_preserves_liveness",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_liveness_insensitive_mreference =
| MG.modifies_preserves_liveness | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_liveness_insensitive_region_mreference | val modifies_liveness_insensitive_region_mreference
(l1 l2 : loc)
(h h' : HS.mem)
(#t: Type)
(#pre: Preorder.preorder t)
(x: HS.mreference t pre)
: Lemma
(requires (modifies (loc_union l1 l2) h h' /\ loc_disjoint l1 (loc_mreference x) /\ region_liveness_insensitive_locs `loc_includes` l2 /\ HS.live_region h (HS.frameOf x)))
(ensures (HS.live_region h' (HS.frameOf x)))
[SMTPatOr [
[SMTPat (modifies (loc_union l1 l2) h h'); SMTPat (HS.live_region h (HS.frameOf x))];
[SMTPat (modifies (loc_union l1 l2) h h'); SMTPat (HS.live_region h' (HS.frameOf x))];
]] | val modifies_liveness_insensitive_region_mreference
(l1 l2 : loc)
(h h' : HS.mem)
(#t: Type)
(#pre: Preorder.preorder t)
(x: HS.mreference t pre)
: Lemma
(requires (modifies (loc_union l1 l2) h h' /\ loc_disjoint l1 (loc_mreference x) /\ region_liveness_insensitive_locs `loc_includes` l2 /\ HS.live_region h (HS.frameOf x)))
(ensures (HS.live_region h' (HS.frameOf x)))
[SMTPatOr [
[SMTPat (modifies (loc_union l1 l2) h h'); SMTPat (HS.live_region h (HS.frameOf x))];
[SMTPat (modifies (loc_union l1 l2) h h'); SMTPat (HS.live_region h' (HS.frameOf x))];
]] | let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 101,
"end_line": 987,
"start_col": 0,
"start_line": 987
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
l1: LowStar.Monotonic.Buffer.loc ->
l2: LowStar.Monotonic.Buffer.loc ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem ->
x: FStar.Monotonic.HyperStack.mreference t pre
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2) h h' /\
LowStar.Monotonic.Buffer.loc_disjoint l1 (LowStar.Monotonic.Buffer.loc_mreference x) /\
LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.region_liveness_insensitive_locs
l2 /\ FStar.Monotonic.HyperStack.live_region h (FStar.Monotonic.HyperStack.frameOf x))
(ensures FStar.Monotonic.HyperStack.live_region h' (FStar.Monotonic.HyperStack.frameOf x))
[
SMTPatOr [
[
SMTPat (LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2)
h
h');
SMTPat (FStar.Monotonic.HyperStack.live_region h
(FStar.Monotonic.HyperStack.frameOf x))
];
[
SMTPat (LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2)
h
h');
SMTPat (FStar.Monotonic.HyperStack.live_region h'
(FStar.Monotonic.HyperStack.frameOf x))
]
]
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_preserves_region_liveness_reference",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_liveness_insensitive_region_mreference =
| MG.modifies_preserves_region_liveness_reference | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.region_liveness_insensitive_buffer | val region_liveness_insensitive_buffer (#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
:Lemma (region_liveness_insensitive_locs `loc_includes` (loc_buffer b))
[SMTPat (region_liveness_insensitive_locs `loc_includes` (loc_buffer b))] | val region_liveness_insensitive_buffer (#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
:Lemma (region_liveness_insensitive_locs `loc_includes` (loc_buffer b))
[SMTPat (region_liveness_insensitive_locs `loc_includes` (loc_buffer b))] | let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 117,
"end_line": 966,
"start_col": 0,
"start_line": 965
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: LowStar.Monotonic.Buffer.mbuffer a rrel rel
-> FStar.Pervasives.Lemma
(ensures
LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.region_liveness_insensitive_locs
(LowStar.Monotonic.Buffer.loc_buffer b))
[
SMTPat (LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.region_liveness_insensitive_locs
(LowStar.Monotonic.Buffer.loc_buffer b))
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.ModifiesGen.loc_includes_region_liveness_insensitive_locs_loc_of_aloc",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer",
"Prims.unit"
] | [] | true | false | true | false | false | let region_liveness_insensitive_buffer #_ #_ #_ b =
| MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_
cls
#(frameOf b)
#(as_addr b)
(ubuffer_of_buffer b) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.address_liveness_insensitive_addresses | val address_liveness_insensitive_addresses (r: HS.rid) (a: Set.set nat) : Lemma
(address_liveness_insensitive_locs `loc_includes` (loc_addresses true r a))
[SMTPat (address_liveness_insensitive_locs `loc_includes` (loc_addresses true r a))] | val address_liveness_insensitive_addresses (r: HS.rid) (a: Set.set nat) : Lemma
(address_liveness_insensitive_locs `loc_includes` (loc_addresses true r a))
[SMTPat (address_liveness_insensitive_locs `loc_includes` (loc_addresses true r a))] | let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 65,
"end_line": 963,
"start_col": 0,
"start_line": 962
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: FStar.Monotonic.HyperHeap.rid -> a: FStar.Set.set Prims.nat
-> FStar.Pervasives.Lemma
(ensures
LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.address_liveness_insensitive_locs
(LowStar.Monotonic.Buffer.loc_addresses true r a))
[
SMTPat (LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.address_liveness_insensitive_locs
(LowStar.Monotonic.Buffer.loc_addresses true r a))
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_includes_address_liveness_insensitive_locs_addresses",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let address_liveness_insensitive_addresses =
| MG.loc_includes_address_liveness_insensitive_locs_addresses cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_liveness_insensitive_buffer | val modifies_liveness_insensitive_buffer
(l1 l2:loc)
(h h':HS.mem)
(#a:Type0) (#rrel #rel:srel a)
(x:mbuffer a rrel rel)
:Lemma (requires (modifies (loc_union l1 l2) h h' /\
loc_disjoint l1 (loc_buffer x) /\
address_liveness_insensitive_locs `loc_includes` l2 /\
live h x))
(ensures (live h' x))
[SMTPatOr [
[SMTPat (live h x); SMTPat (modifies (loc_union l1 l2) h h');];
[SMTPat (live h' x); SMTPat (modifies (loc_union l1 l2) h h');];
]] | val modifies_liveness_insensitive_buffer
(l1 l2:loc)
(h h':HS.mem)
(#a:Type0) (#rrel #rel:srel a)
(x:mbuffer a rrel rel)
:Lemma (requires (modifies (loc_union l1 l2) h h' /\
loc_disjoint l1 (loc_buffer x) /\
address_liveness_insensitive_locs `loc_includes` l2 /\
live h x))
(ensures (live h' x))
[SMTPatOr [
[SMTPat (live h x); SMTPat (modifies (loc_union l1 l2) h h');];
[SMTPat (live h' x); SMTPat (modifies (loc_union l1 l2) h h');];
]] | let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x)) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 79,
"end_line": 983,
"start_col": 0,
"start_line": 979
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
l1: LowStar.Monotonic.Buffer.loc ->
l2: LowStar.Monotonic.Buffer.loc ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem ->
x: LowStar.Monotonic.Buffer.mbuffer a rrel rel
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2) h h' /\
LowStar.Monotonic.Buffer.loc_disjoint l1 (LowStar.Monotonic.Buffer.loc_buffer x) /\
LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.address_liveness_insensitive_locs
l2 /\ LowStar.Monotonic.Buffer.live h x)
(ensures LowStar.Monotonic.Buffer.live h' x)
[
SMTPatOr [
[
SMTPat (LowStar.Monotonic.Buffer.live h x);
SMTPat (LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2)
h
h')
];
[
SMTPat (LowStar.Monotonic.Buffer.live h' x);
SMTPat (LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2)
h
h')
]
]
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.loc",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Monotonic.Buffer.g_is_null",
"Prims.bool",
"LowStar.Monotonic.Buffer.liveness_preservation_intro",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"FStar.ModifiesGen.modifies_preserves_liveness_strong",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer",
"Prims.unit"
] | [] | false | false | true | false | false | let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
| if g_is_null x
then ()
else
liveness_preservation_intro h
h'
x
(fun t' pre r -> MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x)) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.region_liveness_insensitive_addresses | val region_liveness_insensitive_addresses (preserve_liveness: bool) (r: HS.rid) (a: Set.set nat) : Lemma
(region_liveness_insensitive_locs `loc_includes` (loc_addresses preserve_liveness r a))
[SMTPat (region_liveness_insensitive_locs `loc_includes` (loc_addresses preserve_liveness r a))] | val region_liveness_insensitive_addresses (preserve_liveness: bool) (r: HS.rid) (a: Set.set nat) : Lemma
(region_liveness_insensitive_locs `loc_includes` (loc_addresses preserve_liveness r a))
[SMTPat (region_liveness_insensitive_locs `loc_includes` (loc_addresses preserve_liveness r a))] | let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 68,
"end_line": 969,
"start_col": 0,
"start_line": 968
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | preserve_liveness: Prims.bool -> r: FStar.Monotonic.HyperHeap.rid -> a: FStar.Set.set Prims.nat
-> FStar.Pervasives.Lemma
(ensures
LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.region_liveness_insensitive_locs
(LowStar.Monotonic.Buffer.loc_addresses preserve_liveness r a))
[
SMTPat (LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.region_liveness_insensitive_locs
(LowStar.Monotonic.Buffer.loc_addresses preserve_liveness r a))
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_includes_region_liveness_insensitive_locs_loc_addresses",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let region_liveness_insensitive_addresses =
| MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_liveness_insensitive_region_buffer | val modifies_liveness_insensitive_region_buffer
(l1 l2:loc)
(h h':HS.mem)
(#a:Type0) (#rrel #rel:srel a)
(x:mbuffer a rrel rel)
:Lemma (requires (modifies (loc_union l1 l2) h h' /\ loc_disjoint l1 (loc_buffer x) /\ region_liveness_insensitive_locs `loc_includes` l2 /\ HS.live_region h (frameOf x)))
(ensures (HS.live_region h' (frameOf x)))
[SMTPatOr [
[SMTPat (modifies (loc_union l1 l2) h h'); SMTPat (HS.live_region h (frameOf x))];
[SMTPat (modifies (loc_union l1 l2) h h'); SMTPat (HS.live_region h' (frameOf x))];
]] | val modifies_liveness_insensitive_region_buffer
(l1 l2:loc)
(h h':HS.mem)
(#a:Type0) (#rrel #rel:srel a)
(x:mbuffer a rrel rel)
:Lemma (requires (modifies (loc_union l1 l2) h h' /\ loc_disjoint l1 (loc_buffer x) /\ region_liveness_insensitive_locs `loc_includes` l2 /\ HS.live_region h (frameOf x)))
(ensures (HS.live_region h' (frameOf x)))
[SMTPatOr [
[SMTPat (modifies (loc_union l1 l2) h h'); SMTPat (HS.live_region h (frameOf x))];
[SMTPat (modifies (loc_union l1 l2) h h'); SMTPat (HS.live_region h' (frameOf x))];
]] | let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 108,
"end_line": 991,
"start_col": 0,
"start_line": 989
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
l1: LowStar.Monotonic.Buffer.loc ->
l2: LowStar.Monotonic.Buffer.loc ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem ->
x: LowStar.Monotonic.Buffer.mbuffer a rrel rel
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2) h h' /\
LowStar.Monotonic.Buffer.loc_disjoint l1 (LowStar.Monotonic.Buffer.loc_buffer x) /\
LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.region_liveness_insensitive_locs
l2 /\ FStar.Monotonic.HyperStack.live_region h (LowStar.Monotonic.Buffer.frameOf x))
(ensures FStar.Monotonic.HyperStack.live_region h' (LowStar.Monotonic.Buffer.frameOf x))
[
SMTPatOr [
[
SMTPat (LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2)
h
h');
SMTPat (FStar.Monotonic.HyperStack.live_region h (LowStar.Monotonic.Buffer.frameOf x))
];
[
SMTPat (LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l1 l2)
h
h');
SMTPat (FStar.Monotonic.HyperStack.live_region h' (LowStar.Monotonic.Buffer.frameOf x)
)
]
]
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.loc",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Monotonic.Buffer.g_is_null",
"Prims.bool",
"FStar.ModifiesGen.modifies_preserves_region_liveness_aloc",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer",
"Prims.unit"
] | [] | false | false | true | false | false | let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
| if g_is_null x
then ()
else
MG.modifies_preserves_region_liveness_aloc l1
l2
h
h'
#(frameOf x)
#(as_addr x)
(ubuffer_of_buffer x) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.no_upd_fresh_region | val no_upd_fresh_region: r:HS.rid -> l:loc -> h0:HS.mem -> h1:HS.mem -> Lemma
(requires (HS.fresh_region r h0 h1 /\ modifies (loc_union (loc_all_regions_from false r) l) h0 h1))
(ensures (modifies l h0 h1))
[SMTPat (HS.fresh_region r h0 h1); SMTPat (modifies l h0 h1)] | val no_upd_fresh_region: r:HS.rid -> l:loc -> h0:HS.mem -> h1:HS.mem -> Lemma
(requires (HS.fresh_region r h0 h1 /\ modifies (loc_union (loc_all_regions_from false r) l) h0 h1))
(ensures (modifies l h0 h1))
[SMTPat (HS.fresh_region r h0 h1); SMTPat (modifies l h0 h1)] | let no_upd_fresh_region = MG.no_upd_fresh_region | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 997,
"start_col": 0,
"start_line": 997
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: FStar.Monotonic.HyperHeap.rid ->
l: LowStar.Monotonic.Buffer.loc ->
h0: FStar.Monotonic.HyperStack.mem ->
h1: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
FStar.Monotonic.HyperStack.fresh_region r h0 h1 /\
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union (LowStar.Monotonic.Buffer.loc_all_regions_from
false
r)
l)
h0
h1)
(ensures LowStar.Monotonic.Buffer.modifies l h0 h1)
[
SMTPat (FStar.Monotonic.HyperStack.fresh_region r h0 h1);
SMTPat (LowStar.Monotonic.Buffer.modifies l h0 h1)
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.no_upd_fresh_region",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let no_upd_fresh_region =
| MG.no_upd_fresh_region | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.new_region_modifies | val new_region_modifies (m0: HS.mem) (r0: HS.rid) (col: option int) : Lemma
(requires (HST.is_eternal_region r0 /\ HS.live_region m0 r0 /\ (None? col \/ HS.is_heap_color (Some?.v col))))
(ensures (
let (_, m1) = HS.new_eternal_region m0 r0 col in
modifies loc_none m0 m1
))
[SMTPat (HS.new_eternal_region m0 r0 col)] | val new_region_modifies (m0: HS.mem) (r0: HS.rid) (col: option int) : Lemma
(requires (HST.is_eternal_region r0 /\ HS.live_region m0 r0 /\ (None? col \/ HS.is_heap_color (Some?.v col))))
(ensures (
let (_, m1) = HS.new_eternal_region m0 r0 col in
modifies loc_none m0 m1
))
[SMTPat (HS.new_eternal_region m0 r0 col)] | let new_region_modifies = MG.new_region_modifies #_ cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 55,
"end_line": 999,
"start_col": 0,
"start_line": 999
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
m0: FStar.Monotonic.HyperStack.mem ->
r0: FStar.Monotonic.HyperHeap.rid ->
col: FStar.Pervasives.Native.option Prims.int
-> FStar.Pervasives.Lemma
(requires
FStar.HyperStack.ST.is_eternal_region r0 /\ FStar.Monotonic.HyperStack.live_region m0 r0 /\
(None? col \/ FStar.Monotonic.HyperStack.is_heap_color (Some?.v col)))
(ensures
(let _ = FStar.Monotonic.HyperStack.new_eternal_region m0 r0 col in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ _ m1 = _ in
LowStar.Monotonic.Buffer.modifies LowStar.Monotonic.Buffer.loc_none m0 m1)
<:
Type0))
[SMTPat (FStar.Monotonic.HyperStack.new_eternal_region m0 r0 col)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.new_region_modifies",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let new_region_modifies =
| MG.new_region_modifies #_ cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.region_liveness_insensitive_address_liveness_insensitive | val region_liveness_insensitive_address_liveness_insensitive:
squash (region_liveness_insensitive_locs `loc_includes` address_liveness_insensitive_locs) | val region_liveness_insensitive_address_liveness_insensitive:
squash (region_liveness_insensitive_locs `loc_includes` address_liveness_insensitive_locs) | let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 88,
"end_line": 975,
"start_col": 0,
"start_line": 974
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Prims.squash (LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.region_liveness_insensitive_locs
LowStar.Monotonic.Buffer.address_liveness_insensitive_locs) | Prims.Tot | [
"total"
] | [] | [
"FStar.ModifiesGen.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | false | false | true | true | false | let region_liveness_insensitive_address_liveness_insensitive =
| MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_unused_in | val loc_unused_in (h: HS.mem) : GTot loc | val loc_unused_in (h: HS.mem) : GTot loc | let loc_unused_in = MG.loc_unused_in _ | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 1213,
"start_col": 0,
"start_line": 1213
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options
let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h'
let does_not_contain_addr = MG.does_not_contain_addr
let not_live_region_does_not_contain_addr = MG.not_live_region_does_not_contain_addr
let unused_in_does_not_contain_addr = MG.unused_in_does_not_contain_addr
let addr_unused_in_does_not_contain_addr = MG.addr_unused_in_does_not_contain_addr
let free_does_not_contain_addr = MG.free_does_not_contain_addr
let does_not_contain_addr_elim = MG.does_not_contain_addr_elim
let modifies_only_live_addresses = MG.modifies_only_live_addresses
let loc_not_unused_in = MG.loc_not_unused_in _ | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h: FStar.Monotonic.HyperStack.mem -> Prims.GTot LowStar.Monotonic.Buffer.loc | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.ModifiesGen.loc_unused_in",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | false | false | false | false | false | let loc_unused_in =
| MG.loc_unused_in _ | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.region_liveness_insensitive_regions | val region_liveness_insensitive_regions (rs: Set.set HS.rid) : Lemma
(region_liveness_insensitive_locs `loc_includes` (loc_regions true rs))
[SMTPat (region_liveness_insensitive_locs `loc_includes` (loc_regions true rs))] | val region_liveness_insensitive_regions (rs: Set.set HS.rid) : Lemma
(region_liveness_insensitive_locs `loc_includes` (loc_regions true rs))
[SMTPat (region_liveness_insensitive_locs `loc_includes` (loc_regions true rs))] | let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 66,
"end_line": 972,
"start_col": 0,
"start_line": 971
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | rs: FStar.Set.set FStar.Monotonic.HyperHeap.rid
-> FStar.Pervasives.Lemma
(ensures
LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.region_liveness_insensitive_locs
(LowStar.Monotonic.Buffer.loc_regions true rs))
[
SMTPat (LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.region_liveness_insensitive_locs
(LowStar.Monotonic.Buffer.loc_regions true rs))
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_includes_region_liveness_insensitive_locs_loc_regions",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let region_liveness_insensitive_regions =
| MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_disjoint_gsub_buffer | val loc_disjoint_gsub_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel)
(i1:UInt32.t) (len1:UInt32.t) (sub_rel1:srel a)
(i2:UInt32.t) (len2:UInt32.t) (sub_rel2:srel a)
:Lemma (requires (UInt32.v i1 + UInt32.v len1 <= (length b) /\
UInt32.v i2 + UInt32.v len2 <= (length b) /\
(UInt32.v i1 + UInt32.v len1 <= UInt32.v i2 \/
UInt32.v i2 + UInt32.v len2 <= UInt32.v i1)))
(ensures (loc_disjoint (loc_buffer (mgsub sub_rel1 b i1 len1)) (loc_buffer (mgsub sub_rel2 b i2 len2))))
[SMTPat (mgsub sub_rel1 b i1 len1); SMTPat (mgsub sub_rel2 b i2 len2)] | val loc_disjoint_gsub_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel)
(i1:UInt32.t) (len1:UInt32.t) (sub_rel1:srel a)
(i2:UInt32.t) (len2:UInt32.t) (sub_rel2:srel a)
:Lemma (requires (UInt32.v i1 + UInt32.v len1 <= (length b) /\
UInt32.v i2 + UInt32.v len2 <= (length b) /\
(UInt32.v i1 + UInt32.v len1 <= UInt32.v i2 \/
UInt32.v i2 + UInt32.v len2 <= UInt32.v i1)))
(ensures (loc_disjoint (loc_buffer (mgsub sub_rel1 b i1 len1)) (loc_buffer (mgsub sub_rel2 b i2 len2))))
[SMTPat (mgsub sub_rel1 b i1 len1); SMTPat (mgsub sub_rel2 b i2 len2)] | let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 75,
"end_line": 917,
"start_col": 0,
"start_line": 916
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
i1: FStar.UInt32.t ->
len1: FStar.UInt32.t ->
sub_rel1: LowStar.Monotonic.Buffer.srel a ->
i2: FStar.UInt32.t ->
len2: FStar.UInt32.t ->
sub_rel2: LowStar.Monotonic.Buffer.srel a
-> FStar.Pervasives.Lemma
(requires
FStar.UInt32.v i1 + FStar.UInt32.v len1 <= LowStar.Monotonic.Buffer.length b /\
FStar.UInt32.v i2 + FStar.UInt32.v len2 <= LowStar.Monotonic.Buffer.length b /\
(FStar.UInt32.v i1 + FStar.UInt32.v len1 <= FStar.UInt32.v i2 \/
FStar.UInt32.v i2 + FStar.UInt32.v len2 <= FStar.UInt32.v i1))
(ensures
LowStar.Monotonic.Buffer.loc_disjoint (LowStar.Monotonic.Buffer.loc_buffer (LowStar.Monotonic.Buffer.mgsub
sub_rel1
b
i1
len1))
(LowStar.Monotonic.Buffer.loc_buffer (LowStar.Monotonic.Buffer.mgsub sub_rel2 b i2 len2)))
[
SMTPat (LowStar.Monotonic.Buffer.mgsub sub_rel1 b i1 len1);
SMTPat (LowStar.Monotonic.Buffer.mgsub sub_rel2 b i2 len2)
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc_disjoint_buffer",
"LowStar.Monotonic.Buffer.mgsub",
"Prims.unit"
] | [] | true | false | true | false | false | let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
| loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_not_unused_in | val loc_not_unused_in (h: HS.mem) : GTot loc | val loc_not_unused_in (h: HS.mem) : GTot loc | let loc_not_unused_in = MG.loc_not_unused_in _ | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 46,
"end_line": 1211,
"start_col": 0,
"start_line": 1211
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options
let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h'
let does_not_contain_addr = MG.does_not_contain_addr
let not_live_region_does_not_contain_addr = MG.not_live_region_does_not_contain_addr
let unused_in_does_not_contain_addr = MG.unused_in_does_not_contain_addr
let addr_unused_in_does_not_contain_addr = MG.addr_unused_in_does_not_contain_addr
let free_does_not_contain_addr = MG.free_does_not_contain_addr
let does_not_contain_addr_elim = MG.does_not_contain_addr_elim
let modifies_only_live_addresses = MG.modifies_only_live_addresses | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h: FStar.Monotonic.HyperStack.mem -> Prims.GTot LowStar.Monotonic.Buffer.loc | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.ModifiesGen.loc_not_unused_in",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | false | false | false | false | false | let loc_not_unused_in =
| MG.loc_not_unused_in _ | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_loc_regions_intro | val modifies_loc_regions_intro
(rs: Set.set HS.rid)
(h1 h2: HS.mem)
: Lemma
(requires (HS.modifies rs h1 h2))
(ensures (modifies (loc_regions true rs) h1 h2)) | val modifies_loc_regions_intro
(rs: Set.set HS.rid)
(h1 h2: HS.mem)
: Lemma
(requires (HS.modifies rs h1 h2))
(ensures (modifies (loc_regions true rs) h1 h2)) | let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 70,
"end_line": 1003,
"start_col": 0,
"start_line": 1003
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
rs: FStar.Set.set FStar.Monotonic.HyperHeap.rid ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires FStar.Monotonic.HyperStack.modifies rs h1 h2)
(ensures
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_regions true rs) h1 h2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_loc_regions_intro",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_loc_regions_intro =
| MG.modifies_loc_regions_intro #_ #cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_free | val modifies_free
(#a: Type)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel { HS.is_mm r } )
(m: HS.mem { m `HS.contains` r } )
: Lemma
(modifies (loc_freed_mreference r) m (HS.free r m))
[SMTPat (HS.free r m)] | val modifies_free
(#a: Type)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel { HS.is_mm r } )
(m: HS.mem { m `HS.contains` r } )
: Lemma
(modifies (loc_freed_mreference r) m (HS.free r m))
[SMTPat (HS.free r m)] | let modifies_free = MG.modifies_free #_ #cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 1011,
"start_col": 0,
"start_line": 1011
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: FStar.Monotonic.HyperStack.mreference a rel {FStar.Monotonic.HyperStack.is_mm r} ->
m: FStar.Monotonic.HyperStack.mem{FStar.Monotonic.HyperStack.contains m r}
-> FStar.Pervasives.Lemma
(ensures
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_freed_mreference r)
m
(FStar.Monotonic.HyperStack.free r m)) [SMTPat (FStar.Monotonic.HyperStack.free r m)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_free",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_free =
| MG.modifies_free #_ #cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_only_live_regions | val modifies_only_live_regions
(rs: Set.set HS.rid)
(l: loc)
(h h' : HS.mem)
: Lemma
(requires (
modifies (loc_union (loc_regions false rs) l) h h' /\
(forall r . Set.mem r rs ==> (~ (HS.live_region h r)))
))
(ensures (modifies l h h')) | val modifies_only_live_regions
(rs: Set.set HS.rid)
(l: loc)
(h h' : HS.mem)
: Lemma
(requires (
modifies (loc_union (loc_regions false rs) l) h h' /\
(forall r . Set.mem r rs ==> (~ (HS.live_region h r)))
))
(ensures (modifies l h h')) | let modifies_only_live_regions = MG.modifies_only_live_regions | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 995,
"start_col": 0,
"start_line": 995
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
rs: FStar.Set.set FStar.Monotonic.HyperHeap.rid ->
l: LowStar.Monotonic.Buffer.loc ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union (LowStar.Monotonic.Buffer.loc_regions
false
rs)
l)
h
h' /\
(forall (r: FStar.Monotonic.HyperHeap.rid).
FStar.Set.mem r rs ==> ~(FStar.Monotonic.HyperStack.live_region h r)))
(ensures LowStar.Monotonic.Buffer.modifies l h h') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_only_live_regions",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_only_live_regions =
| MG.modifies_only_live_regions | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_ralloc_post | val modifies_ralloc_post
(#a: Type)
(#rel: Preorder.preorder a)
(i: HS.rid)
(init: a)
(h: HS.mem)
(x: HST.mreference a rel)
(h' : HS.mem)
: Lemma
(requires (HST.ralloc_post i init h x h'))
(ensures (modifies loc_none h h'))
[SMTPat (HST.ralloc_post i init h x h')] | val modifies_ralloc_post
(#a: Type)
(#rel: Preorder.preorder a)
(i: HS.rid)
(init: a)
(h: HS.mem)
(x: HST.mreference a rel)
(h' : HS.mem)
: Lemma
(requires (HST.ralloc_post i init h x h'))
(ensures (modifies loc_none h h'))
[SMTPat (HST.ralloc_post i init h x h')] | let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 58,
"end_line": 1007,
"start_col": 0,
"start_line": 1007
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
i: FStar.Monotonic.HyperHeap.rid ->
init: a ->
h: FStar.Monotonic.HyperStack.mem ->
x: FStar.HyperStack.ST.mreference a rel ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires FStar.HyperStack.ST.ralloc_post i init h x h')
(ensures LowStar.Monotonic.Buffer.modifies LowStar.Monotonic.Buffer.loc_none h h')
[SMTPat (FStar.HyperStack.ST.ralloc_post i init h x h')] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_ralloc_post",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_ralloc_post =
| MG.modifies_ralloc_post #_ #cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_loc_addresses_intro | val modifies_loc_addresses_intro
(r: HS.rid)
(a: Set.set nat)
(l: loc)
(h1 h2: HS.mem)
: Lemma
(requires (
HS.live_region h2 r /\
modifies (loc_union (loc_region_only false r) l) h1 h2 /\
HS.modifies_ref r a h1 h2
))
(ensures (modifies (loc_union (loc_addresses true r a) l) h1 h2)) | val modifies_loc_addresses_intro
(r: HS.rid)
(a: Set.set nat)
(l: loc)
(h1 h2: HS.mem)
: Lemma
(requires (
HS.live_region h2 r /\
modifies (loc_union (loc_region_only false r) l) h1 h2 /\
HS.modifies_ref r a h1 h2
))
(ensures (modifies (loc_union (loc_addresses true r a) l) h1 h2)) | let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 74,
"end_line": 1005,
"start_col": 0,
"start_line": 1005
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: FStar.Monotonic.HyperHeap.rid ->
a: FStar.Set.set Prims.nat ->
l: LowStar.Monotonic.Buffer.loc ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
FStar.Monotonic.HyperStack.live_region h2 r /\
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union (LowStar.Monotonic.Buffer.loc_region_only
false
r)
l)
h1
h2 /\ FStar.Monotonic.HyperStack.modifies_ref r a h1 h2)
(ensures
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union (LowStar.Monotonic.Buffer.loc_addresses
true
r
a)
l)
h1
h2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_loc_addresses_intro",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_loc_addresses_intro =
| MG.modifies_loc_addresses_intro #_ #cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_0_modifies | val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2)) | val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2)) | let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 47,
"end_line": 1026,
"start_col": 0,
"start_line": 1022
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h1: FStar.Monotonic.HyperStack.mem -> h2: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires LowStar.Monotonic.Buffer.modifies_0 h1 h2)
(ensures LowStar.Monotonic.Buffer.modifies LowStar.Monotonic.Buffer.loc_none h1 h2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"FStar.ModifiesGen.modifies_none_intro",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.modifies_0_live_region",
"Prims.unit",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"LowStar.Monotonic.Buffer.modifies_0_mreference",
"Prims.nat",
"LowStar.Monotonic.Buffer.modifies_0_unused_in"
] | [] | false | false | true | false | false | let modifies_0_modifies h1 h2 =
| MG.modifies_none_intro #_
#cls
h1
h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_upd | val modifies_upd
(#t: Type) (#pre: Preorder.preorder t)
(r: HS.mreference t pre)
(v: t)
(h: HS.mem)
: Lemma
(requires (HS.contains h r))
(ensures (modifies (loc_mreference r) h (HS.upd h r v)))
[SMTPat (HS.upd h r v)] | val modifies_upd
(#t: Type) (#pre: Preorder.preorder t)
(r: HS.mreference t pre)
(v: t)
(h: HS.mem)
: Lemma
(requires (HS.contains h r))
(ensures (modifies (loc_mreference r) h (HS.upd h r v)))
[SMTPat (HS.upd h r v)] | let modifies_upd = MG.modifies_upd #_ #cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 1015,
"start_col": 0,
"start_line": 1015
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: FStar.Monotonic.HyperStack.mreference t pre -> v: t -> h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires FStar.Monotonic.HyperStack.contains h r)
(ensures
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_mreference r)
h
(FStar.Monotonic.HyperStack.upd h r v))
[SMTPat (FStar.Monotonic.HyperStack.upd h r v)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_upd",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_upd =
| MG.modifies_upd #_ #cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_1_modifies | val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2)) | val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2)) | let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 1061,
"start_col": 0,
"start_line": 1033
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires LowStar.Monotonic.Buffer.modifies_1 b h1 h2)
(ensures LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_buffer b) h1 h2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Monotonic.Buffer.modifies_0_modifies",
"Prims.unit",
"LowStar.Monotonic.Buffer.modifies_1_null",
"Prims.bool",
"FStar.ModifiesGen.modifies_intro",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.loc_buffer",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.modifies_1_live_region",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"LowStar.Monotonic.Buffer.modifies_1_mreference",
"FStar.ModifiesGen.loc_disjoint_aloc_addresses_elim",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer",
"FStar.Monotonic.HyperStack.frameOf",
"FStar.Set.singleton",
"Prims.nat",
"FStar.Monotonic.HyperStack.as_addr",
"LowStar.Monotonic.Buffer.loc_disjoint_sym",
"LowStar.Monotonic.Buffer.loc_mreference",
"LowStar.Monotonic.Buffer.modifies_1_liveness",
"LowStar.Monotonic.Buffer.modifies_1_unused_in",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"LowStar.Monotonic.Buffer.modifies_1_ubuffer",
"LowStar.Monotonic.Buffer.same_mreference_ubuffer_preserved",
"FStar.ModifiesGen.loc_disjoint_aloc_elim",
"FStar.ModifiesGen.loc_of_aloc"
] | [] | false | false | true | false | false | let modifies_1_modifies #t #_ #_ b h1 h2 =
| if g_is_null b
then
(modifies_1_null b h1 h2;
modifies_0_modifies h1 h2)
else
MG.modifies_intro (loc_buffer b)
h1
h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_
#cls
#(frameOf b)
#(as_addr b)
(ubuffer_of_buffer b)
true
(HS.frameOf p)
(Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p)
(fun t pre p -> modifies_1_liveness b h1 h2 p)
(fun r n -> modifies_1_unused_in b h1 h2 r n)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r'
#a'
b'
h1
h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_fresh_frame_popped | val modifies_fresh_frame_popped
(h0 h1: HS.mem)
(s: loc)
(h2 h3: HS.mem)
: Lemma
(requires (
HS.fresh_frame h0 h1 /\
modifies (loc_union (loc_all_regions_from false (HS.get_tip h1)) s) h1 h2 /\
(HS.get_tip h2) == (HS.get_tip h1) /\
HS.popped h2 h3
))
(ensures (
modifies s h0 h3 /\
(HS.get_tip h3) == HS.get_tip h0
)) | val modifies_fresh_frame_popped
(h0 h1: HS.mem)
(s: loc)
(h2 h3: HS.mem)
: Lemma
(requires (
HS.fresh_frame h0 h1 /\
modifies (loc_union (loc_all_regions_from false (HS.get_tip h1)) s) h1 h2 /\
(HS.get_tip h2) == (HS.get_tip h1) /\
HS.popped h2 h3
))
(ensures (
modifies s h0 h3 /\
(HS.get_tip h3) == HS.get_tip h0
)) | let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 64,
"end_line": 1001,
"start_col": 0,
"start_line": 1001
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h0: FStar.Monotonic.HyperStack.mem ->
h1: FStar.Monotonic.HyperStack.mem ->
s: LowStar.Monotonic.Buffer.loc ->
h2: FStar.Monotonic.HyperStack.mem ->
h3: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
FStar.Monotonic.HyperStack.fresh_frame h0 h1 /\
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union (LowStar.Monotonic.Buffer.loc_all_regions_from
false
(FStar.Monotonic.HyperStack.get_tip h1))
s)
h1
h2 /\ FStar.Monotonic.HyperStack.get_tip h2 == FStar.Monotonic.HyperStack.get_tip h1 /\
FStar.Monotonic.HyperStack.popped h2 h3)
(ensures
LowStar.Monotonic.Buffer.modifies s h0 h3 /\
FStar.Monotonic.HyperStack.get_tip h3 == FStar.Monotonic.HyperStack.get_tip h0) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_fresh_frame_popped",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_fresh_frame_popped =
| MG.modifies_fresh_frame_popped | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_addr_of_modifies | val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2)) | val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2)) | let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 1110,
"start_col": 0,
"start_line": 1102
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires LowStar.Monotonic.Buffer.modifies_addr_of b h1 h2)
(ensures
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_addr_of_buffer b) h1 h2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.Monotonic.HyperStack.mem",
"FStar.ModifiesGen.modifies_address_intro",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.modifies_addr_of_live_region",
"Prims.unit",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"LowStar.Monotonic.Buffer.modifies_addr_of_mreference",
"Prims.nat",
"LowStar.Monotonic.Buffer.modifies_addr_of_unused_in"
] | [] | false | false | true | false | false | let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
| MG.modifies_address_intro #_
#cls
(frameOf b)
(as_addr b)
h1
h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p -> modifies_addr_of_mreference b h1 h2 p)
(fun r n -> modifies_addr_of_unused_in b h1 h2 r n) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_none_modifies | val modifies_none_modifies
(h1 h2: HS.mem)
: Lemma
(requires (HST.modifies_none h1 h2))
(ensures (modifies loc_none h1 h2))
[SMTPat (HST.modifies_none h1 h2)] | val modifies_none_modifies
(h1 h2: HS.mem)
: Lemma
(requires (HST.modifies_none h1 h2))
(ensures (modifies loc_none h1 h2))
[SMTPat (HST.modifies_none h1 h2)] | let modifies_none_modifies = MG.modifies_none_modifies #_ #cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 1013,
"start_col": 0,
"start_line": 1013
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h1: FStar.Monotonic.HyperStack.mem -> h2: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires FStar.HyperStack.ST.modifies_none h1 h2)
(ensures LowStar.Monotonic.Buffer.modifies LowStar.Monotonic.Buffer.loc_none h1 h2)
[SMTPat (FStar.HyperStack.ST.modifies_none h1 h2)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_none_modifies",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_none_modifies =
| MG.modifies_none_modifies #_ #cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.not_live_region_does_not_contain_addr | val not_live_region_does_not_contain_addr
(h: HS.mem)
(ra: HS.rid * nat)
: Lemma
(requires (~ (HS.live_region h (fst ra))))
(ensures (h `does_not_contain_addr` ra)) | val not_live_region_does_not_contain_addr
(h: HS.mem)
(ra: HS.rid * nat)
: Lemma
(requires (~ (HS.live_region h (fst ra))))
(ensures (h `does_not_contain_addr` ra)) | let not_live_region_does_not_contain_addr = MG.not_live_region_does_not_contain_addr | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 84,
"end_line": 1199,
"start_col": 0,
"start_line": 1199
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options
let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h'
let does_not_contain_addr = MG.does_not_contain_addr | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h: FStar.Monotonic.HyperStack.mem -> ra: (FStar.Monotonic.HyperHeap.rid * Prims.nat)
-> FStar.Pervasives.Lemma
(requires ~(FStar.Monotonic.HyperStack.live_region h (FStar.Pervasives.Native.fst ra)))
(ensures LowStar.Monotonic.Buffer.does_not_contain_addr h ra) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.not_live_region_does_not_contain_addr"
] | [] | true | false | true | false | false | let not_live_region_does_not_contain_addr =
| MG.not_live_region_does_not_contain_addr | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.does_not_contain_addr_elim | val does_not_contain_addr_elim
(#a: Type0)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel)
(m: HS.mem)
(x: HS.rid * nat)
: Lemma
(requires (
m `does_not_contain_addr` x /\
HS.frameOf r == fst x /\
HS.as_addr r == snd x
))
(ensures (~ (m `HS.contains` r))) | val does_not_contain_addr_elim
(#a: Type0)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel)
(m: HS.mem)
(x: HS.rid * nat)
: Lemma
(requires (
m `does_not_contain_addr` x /\
HS.frameOf r == fst x /\
HS.as_addr r == snd x
))
(ensures (~ (m `HS.contains` r))) | let does_not_contain_addr_elim = MG.does_not_contain_addr_elim | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 1207,
"start_col": 0,
"start_line": 1207
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options
let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h'
let does_not_contain_addr = MG.does_not_contain_addr
let not_live_region_does_not_contain_addr = MG.not_live_region_does_not_contain_addr
let unused_in_does_not_contain_addr = MG.unused_in_does_not_contain_addr
let addr_unused_in_does_not_contain_addr = MG.addr_unused_in_does_not_contain_addr
let free_does_not_contain_addr = MG.free_does_not_contain_addr | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: FStar.Monotonic.HyperStack.mreference a rel ->
m: FStar.Monotonic.HyperStack.mem ->
x: (FStar.Monotonic.HyperHeap.rid * Prims.nat)
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.does_not_contain_addr m x /\
FStar.Monotonic.HyperStack.frameOf r == FStar.Pervasives.Native.fst x /\
FStar.Monotonic.HyperStack.as_addr r == FStar.Pervasives.Native.snd x)
(ensures ~(FStar.Monotonic.HyperStack.contains m r)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.does_not_contain_addr_elim"
] | [] | true | false | true | false | false | let does_not_contain_addr_elim =
| MG.does_not_contain_addr_elim | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.unused_in_does_not_contain_addr | val unused_in_does_not_contain_addr
(h: HS.mem)
(#a: Type)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel)
: Lemma
(requires (r `HS.unused_in` h))
(ensures (h `does_not_contain_addr` (HS.frameOf r, HS.as_addr r))) | val unused_in_does_not_contain_addr
(h: HS.mem)
(#a: Type)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel)
: Lemma
(requires (r `HS.unused_in` h))
(ensures (h `does_not_contain_addr` (HS.frameOf r, HS.as_addr r))) | let unused_in_does_not_contain_addr = MG.unused_in_does_not_contain_addr | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 72,
"end_line": 1201,
"start_col": 0,
"start_line": 1201
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options
let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h'
let does_not_contain_addr = MG.does_not_contain_addr
let not_live_region_does_not_contain_addr = MG.not_live_region_does_not_contain_addr | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h: FStar.Monotonic.HyperStack.mem -> r: FStar.Monotonic.HyperStack.mreference a rel
-> FStar.Pervasives.Lemma (requires FStar.Monotonic.HyperStack.unused_in r h)
(ensures
LowStar.Monotonic.Buffer.does_not_contain_addr h
(FStar.Monotonic.HyperStack.frameOf r,
FStar.Monotonic.HyperStack.as_addr r)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.unused_in_does_not_contain_addr"
] | [] | true | false | true | false | false | let unused_in_does_not_contain_addr =
| MG.unused_in_does_not_contain_addr | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.addr_unused_in_does_not_contain_addr | val addr_unused_in_does_not_contain_addr
(h: HS.mem)
(ra: HS.rid * nat)
: Lemma
(requires (HS.live_region h (fst ra) ==> snd ra `Heap.addr_unused_in` (Map.sel (HS.get_hmap h) (fst ra))))
(ensures (h `does_not_contain_addr` ra)) | val addr_unused_in_does_not_contain_addr
(h: HS.mem)
(ra: HS.rid * nat)
: Lemma
(requires (HS.live_region h (fst ra) ==> snd ra `Heap.addr_unused_in` (Map.sel (HS.get_hmap h) (fst ra))))
(ensures (h `does_not_contain_addr` ra)) | let addr_unused_in_does_not_contain_addr = MG.addr_unused_in_does_not_contain_addr | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 82,
"end_line": 1203,
"start_col": 0,
"start_line": 1203
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options
let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h'
let does_not_contain_addr = MG.does_not_contain_addr
let not_live_region_does_not_contain_addr = MG.not_live_region_does_not_contain_addr
let unused_in_does_not_contain_addr = MG.unused_in_does_not_contain_addr | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h: FStar.Monotonic.HyperStack.mem -> ra: (FStar.Monotonic.HyperHeap.rid * Prims.nat)
-> FStar.Pervasives.Lemma
(requires
FStar.Monotonic.HyperStack.live_region h (FStar.Pervasives.Native.fst ra) ==>
FStar.Monotonic.Heap.addr_unused_in (FStar.Pervasives.Native.snd ra)
(FStar.Map.sel (FStar.Monotonic.HyperStack.get_hmap h) (FStar.Pervasives.Native.fst ra)))
(ensures LowStar.Monotonic.Buffer.does_not_contain_addr h ra) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.addr_unused_in_does_not_contain_addr"
] | [] | true | false | true | false | false | let addr_unused_in_does_not_contain_addr =
| MG.addr_unused_in_does_not_contain_addr | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_loc_buffer_from_to_intro | val modifies_loc_buffer_from_to_intro
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h')) | val modifies_loc_buffer_from_to_intro
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h')) | let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h' | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 58,
"end_line": 1195,
"start_col": 0,
"start_line": 1192
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
from: FStar.UInt32.t ->
to: FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
(let s = LowStar.Monotonic.Buffer.as_seq h b in
let s' = LowStar.Monotonic.Buffer.as_seq h' b in
LowStar.Monotonic.Buffer.live h b /\
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l
(LowStar.Monotonic.Buffer.loc_buffer b))
h
h' /\ FStar.UInt32.v from <= FStar.UInt32.v to /\
FStar.UInt32.v to <= LowStar.Monotonic.Buffer.length b /\
FStar.Seq.Base.equal (FStar.Seq.Base.slice s 0 (FStar.UInt32.v from))
(FStar.Seq.Base.slice s' 0 (FStar.UInt32.v from)) /\
FStar.Seq.Base.equal (FStar.Seq.Base.slice s
(FStar.UInt32.v to)
(LowStar.Monotonic.Buffer.length b))
(FStar.Seq.Base.slice s' (FStar.UInt32.v to) (LowStar.Monotonic.Buffer.length b))))
(ensures
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union l
(LowStar.Monotonic.Buffer.loc_buffer_from_to b from to))
h
h') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.g_is_null",
"Prims.bool",
"LowStar.Monotonic.Buffer.modifies_loc_buffer_from_to_intro'",
"Prims.unit"
] | [] | false | false | true | false | false | let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
| if g_is_null b then () else modifies_loc_buffer_from_to_intro' b from to l h h' | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.free_does_not_contain_addr | val free_does_not_contain_addr
(#a: Type0)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel)
(m: HS.mem)
(x: HS.rid * nat)
: Lemma
(requires (
HS.is_mm r /\
m `HS.contains` r /\
fst x == HS.frameOf r /\
snd x == HS.as_addr r
))
(ensures (
HS.free r m `does_not_contain_addr` x
))
[SMTPat (HS.free r m `does_not_contain_addr` x)] | val free_does_not_contain_addr
(#a: Type0)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel)
(m: HS.mem)
(x: HS.rid * nat)
: Lemma
(requires (
HS.is_mm r /\
m `HS.contains` r /\
fst x == HS.frameOf r /\
snd x == HS.as_addr r
))
(ensures (
HS.free r m `does_not_contain_addr` x
))
[SMTPat (HS.free r m `does_not_contain_addr` x)] | let free_does_not_contain_addr = MG.free_does_not_contain_addr | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 1205,
"start_col": 0,
"start_line": 1205
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options
let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h'
let does_not_contain_addr = MG.does_not_contain_addr
let not_live_region_does_not_contain_addr = MG.not_live_region_does_not_contain_addr
let unused_in_does_not_contain_addr = MG.unused_in_does_not_contain_addr
let addr_unused_in_does_not_contain_addr = MG.addr_unused_in_does_not_contain_addr | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: FStar.Monotonic.HyperStack.mreference a rel ->
m: FStar.Monotonic.HyperStack.mem ->
x: (FStar.Monotonic.HyperHeap.rid * Prims.nat)
-> FStar.Pervasives.Lemma
(requires
FStar.Monotonic.HyperStack.is_mm r /\ FStar.Monotonic.HyperStack.contains m r /\
FStar.Pervasives.Native.fst x == FStar.Monotonic.HyperStack.frameOf r /\
FStar.Pervasives.Native.snd x == FStar.Monotonic.HyperStack.as_addr r)
(ensures
LowStar.Monotonic.Buffer.does_not_contain_addr (FStar.Monotonic.HyperStack.free r m) x)
[
SMTPat (LowStar.Monotonic.Buffer.does_not_contain_addr (FStar.Monotonic.HyperStack.free r m)
x)
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.free_does_not_contain_addr"
] | [] | true | false | true | false | false | let free_does_not_contain_addr =
| MG.free_does_not_contain_addr | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_salloc_post | val modifies_salloc_post
(#a: Type)
(#rel: Preorder.preorder a)
(init: a)
(h: HS.mem)
(x: HST.mreference a rel { HS.is_stack_region (HS.frameOf x) } )
(h' : HS.mem)
: Lemma
(requires (HST.salloc_post init h x h'))
(ensures (modifies loc_none h h'))
[SMTPat (HST.salloc_post init h x h')] | val modifies_salloc_post
(#a: Type)
(#rel: Preorder.preorder a)
(init: a)
(h: HS.mem)
(x: HST.mreference a rel { HS.is_stack_region (HS.frameOf x) } )
(h' : HS.mem)
: Lemma
(requires (HST.salloc_post init h x h'))
(ensures (modifies loc_none h h'))
[SMTPat (HST.salloc_post init h x h')] | let modifies_salloc_post = MG.modifies_salloc_post #_ #cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 58,
"end_line": 1009,
"start_col": 0,
"start_line": 1009
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
init: a ->
h: FStar.Monotonic.HyperStack.mem ->
x:
FStar.HyperStack.ST.mreference a rel
{FStar.Monotonic.HyperStack.is_stack_region (FStar.Monotonic.HyperStack.frameOf x)} ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires FStar.HyperStack.ST.salloc_post init h x h')
(ensures LowStar.Monotonic.Buffer.modifies LowStar.Monotonic.Buffer.loc_none h h')
[SMTPat (FStar.HyperStack.ST.salloc_post init h x h')] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_salloc_post",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_salloc_post =
| MG.modifies_salloc_post #_ #cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_1_from_to_modifies | val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2)) | val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2)) | let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 1095,
"start_col": 0,
"start_line": 1068
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Monotonic.Buffer.mbuffer a rrel rel ->
from: FStar.UInt32.t ->
to: FStar.UInt32.t ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires LowStar.Monotonic.Buffer.modifies_1_from_to b from to h1 h2)
(ensures
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_buffer_from_to b from to)
h1
h2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer_from_to_none_cond",
"LowStar.Monotonic.Buffer.modifies_0_modifies",
"Prims.bool",
"FStar.ModifiesGen.modifies_intro",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.loc_buffer_from_to",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.modifies_1_from_to_live_region",
"Prims.unit",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"LowStar.Monotonic.Buffer.modifies_1_from_to_mreference",
"FStar.ModifiesGen.loc_disjoint_aloc_addresses_elim",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.as_addr",
"LowStar.Monotonic.Buffer.ubuffer_of_buffer_from_to",
"FStar.Monotonic.HyperStack.frameOf",
"FStar.Set.singleton",
"Prims.nat",
"FStar.Monotonic.HyperStack.as_addr",
"LowStar.Monotonic.Buffer.loc_disjoint_sym",
"LowStar.Monotonic.Buffer.loc_mreference",
"LowStar.Monotonic.Buffer.modifies_1_from_to_liveness",
"LowStar.Monotonic.Buffer.modifies_1_from_to_unused_in",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"LowStar.Monotonic.Buffer.modifies_1_from_to_ubuffer",
"LowStar.Monotonic.Buffer.same_mreference_ubuffer_preserved",
"FStar.ModifiesGen.loc_disjoint_aloc_elim",
"FStar.ModifiesGen.loc_of_aloc"
] | [] | false | false | true | false | false | let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
| if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0_modifies h1 h2
else
MG.modifies_intro (loc_buffer_from_to b from to)
h1
h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_
#cls
#(frameOf b)
#(as_addr b)
(ubuffer_of_buffer_from_to b from to)
true
(HS.frameOf p)
(Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p)
(fun t pre p -> modifies_1_from_to_liveness b from to h1 h2 p)
(fun r n -> modifies_1_from_to_unused_in b from to h1 h2 r n)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_
#cls
#(frameOf b)
#(as_addr b)
#r'
#a'
(ubuffer_of_buffer_from_to b from to)
b';
if frameOf b = r' && as_addr b = a'
then modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r'
#a'
b'
h1
h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.not_live_region_loc_not_unused_in_disjoint | val not_live_region_loc_not_unused_in_disjoint
(h0: HS.mem)
(r: HS.rid)
: Lemma
(requires (~ (HS.live_region h0 r)))
(ensures (loc_disjoint (loc_region_only false r) (loc_not_unused_in h0))) | val not_live_region_loc_not_unused_in_disjoint
(h0: HS.mem)
(r: HS.rid)
: Lemma
(requires (~ (HS.live_region h0 r)))
(ensures (loc_disjoint (loc_region_only false r) (loc_not_unused_in h0))) | let not_live_region_loc_not_unused_in_disjoint = MG.not_live_region_loc_not_unused_in_disjoint cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 98,
"end_line": 1220,
"start_col": 0,
"start_line": 1220
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options
let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h'
let does_not_contain_addr = MG.does_not_contain_addr
let not_live_region_does_not_contain_addr = MG.not_live_region_does_not_contain_addr
let unused_in_does_not_contain_addr = MG.unused_in_does_not_contain_addr
let addr_unused_in_does_not_contain_addr = MG.addr_unused_in_does_not_contain_addr
let free_does_not_contain_addr = MG.free_does_not_contain_addr
let does_not_contain_addr_elim = MG.does_not_contain_addr_elim
let modifies_only_live_addresses = MG.modifies_only_live_addresses
let loc_not_unused_in = MG.loc_not_unused_in _
let loc_unused_in = MG.loc_unused_in _
let loc_regions_unused_in = MG.loc_regions_unused_in cls
let loc_unused_in_not_unused_in_disjoint =
MG.loc_unused_in_not_unused_in_disjoint cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h0: FStar.Monotonic.HyperStack.mem -> r: FStar.Monotonic.HyperHeap.rid
-> FStar.Pervasives.Lemma (requires ~(FStar.Monotonic.HyperStack.live_region h0 r))
(ensures
LowStar.Monotonic.Buffer.loc_disjoint (LowStar.Monotonic.Buffer.loc_region_only false r)
(LowStar.Monotonic.Buffer.loc_not_unused_in h0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.not_live_region_loc_not_unused_in_disjoint",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let not_live_region_loc_not_unused_in_disjoint =
| MG.not_live_region_loc_not_unused_in_disjoint cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_only_live_addresses | val modifies_only_live_addresses
(r: HS.rid)
(a: Set.set nat)
(l: loc)
(h h' : HS.mem)
: Lemma
(requires (
modifies (loc_union (loc_addresses false r a) l) h h' /\
(forall x . Set.mem x a ==> h `does_not_contain_addr` (r, x))
))
(ensures (modifies l h h')) | val modifies_only_live_addresses
(r: HS.rid)
(a: Set.set nat)
(l: loc)
(h h' : HS.mem)
: Lemma
(requires (
modifies (loc_union (loc_addresses false r a) l) h h' /\
(forall x . Set.mem x a ==> h `does_not_contain_addr` (r, x))
))
(ensures (modifies l h h')) | let modifies_only_live_addresses = MG.modifies_only_live_addresses | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 66,
"end_line": 1209,
"start_col": 0,
"start_line": 1209
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options
let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h'
let does_not_contain_addr = MG.does_not_contain_addr
let not_live_region_does_not_contain_addr = MG.not_live_region_does_not_contain_addr
let unused_in_does_not_contain_addr = MG.unused_in_does_not_contain_addr
let addr_unused_in_does_not_contain_addr = MG.addr_unused_in_does_not_contain_addr
let free_does_not_contain_addr = MG.free_does_not_contain_addr
let does_not_contain_addr_elim = MG.does_not_contain_addr_elim | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: FStar.Monotonic.HyperHeap.rid ->
a: FStar.Set.set Prims.nat ->
l: LowStar.Monotonic.Buffer.loc ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.modifies (LowStar.Monotonic.Buffer.loc_union (LowStar.Monotonic.Buffer.loc_addresses
false
r
a)
l)
h
h' /\
(forall (x: Prims.nat).
FStar.Set.mem x a ==> LowStar.Monotonic.Buffer.does_not_contain_addr h (r, x)))
(ensures LowStar.Monotonic.Buffer.modifies l h h') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_only_live_addresses",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_only_live_addresses =
| MG.modifies_only_live_addresses | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.live_loc_not_unused_in | val live_loc_not_unused_in (#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel) (h:HS.mem)
:Lemma (requires (live h b))
(ensures (loc_not_unused_in h `loc_includes` loc_addr_of_buffer b))
[SMTPat (live h b)] | val live_loc_not_unused_in (#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel) (h:HS.mem)
:Lemma (requires (live h b))
(ensures (loc_not_unused_in h `loc_includes` loc_addr_of_buffer b))
[SMTPat (live h b)] | let live_loc_not_unused_in #_ #_ #_ b h =
unused_in_equiv b h;
Classical.move_requires (MG.does_not_contain_addr_addr_unused_in h) (frameOf b, as_addr b);
MG.loc_addresses_not_unused_in cls (frameOf b) (Set.singleton (as_addr b)) h;
() | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 4,
"end_line": 1226,
"start_col": 0,
"start_line": 1222
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options
let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h'
let does_not_contain_addr = MG.does_not_contain_addr
let not_live_region_does_not_contain_addr = MG.not_live_region_does_not_contain_addr
let unused_in_does_not_contain_addr = MG.unused_in_does_not_contain_addr
let addr_unused_in_does_not_contain_addr = MG.addr_unused_in_does_not_contain_addr
let free_does_not_contain_addr = MG.free_does_not_contain_addr
let does_not_contain_addr_elim = MG.does_not_contain_addr_elim
let modifies_only_live_addresses = MG.modifies_only_live_addresses
let loc_not_unused_in = MG.loc_not_unused_in _
let loc_unused_in = MG.loc_unused_in _
let loc_regions_unused_in = MG.loc_regions_unused_in cls
let loc_unused_in_not_unused_in_disjoint =
MG.loc_unused_in_not_unused_in_disjoint cls
let not_live_region_loc_not_unused_in_disjoint = MG.not_live_region_loc_not_unused_in_disjoint cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: LowStar.Monotonic.Buffer.mbuffer a rrel rel -> h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires LowStar.Monotonic.Buffer.live h b)
(ensures
LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_not_unused_in h)
(LowStar.Monotonic.Buffer.loc_addr_of_buffer b))
[SMTPat (LowStar.Monotonic.Buffer.live h b)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.Monotonic.HyperStack.mem",
"Prims.unit",
"FStar.ModifiesGen.loc_addresses_not_unused_in",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls",
"LowStar.Monotonic.Buffer.frameOf",
"FStar.Set.singleton",
"Prims.nat",
"LowStar.Monotonic.Buffer.as_addr",
"FStar.Classical.move_requires",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.HyperHeap.rid",
"FStar.ModifiesGen.does_not_contain_addr",
"Prims.l_imp",
"Prims.b2t",
"FStar.Monotonic.HyperStack.live_region",
"FStar.Pervasives.Native.fst",
"FStar.Monotonic.Heap.addr_unused_in",
"FStar.Pervasives.Native.snd",
"FStar.Map.sel",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.HyperStack.get_hmap",
"FStar.ModifiesGen.does_not_contain_addr_addr_unused_in",
"FStar.Pervasives.Native.Mktuple2",
"LowStar.Monotonic.Buffer.unused_in_equiv"
] | [] | false | false | true | false | false | let live_loc_not_unused_in #_ #_ #_ b h =
| unused_in_equiv b h;
Classical.move_requires (MG.does_not_contain_addr_addr_unused_in h) (frameOf b, as_addr b);
MG.loc_addresses_not_unused_in cls (frameOf b) (Set.singleton (as_addr b)) h;
() | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.loc_unused_in_not_unused_in_disjoint | val loc_unused_in_not_unused_in_disjoint (h: HS.mem) : Lemma
(loc_disjoint (loc_unused_in h) (loc_not_unused_in h)) | val loc_unused_in_not_unused_in_disjoint (h: HS.mem) : Lemma
(loc_disjoint (loc_unused_in h) (loc_not_unused_in h)) | let loc_unused_in_not_unused_in_disjoint =
MG.loc_unused_in_not_unused_in_disjoint cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 45,
"end_line": 1218,
"start_col": 0,
"start_line": 1217
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options
let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h'
let does_not_contain_addr = MG.does_not_contain_addr
let not_live_region_does_not_contain_addr = MG.not_live_region_does_not_contain_addr
let unused_in_does_not_contain_addr = MG.unused_in_does_not_contain_addr
let addr_unused_in_does_not_contain_addr = MG.addr_unused_in_does_not_contain_addr
let free_does_not_contain_addr = MG.free_does_not_contain_addr
let does_not_contain_addr_elim = MG.does_not_contain_addr_elim
let modifies_only_live_addresses = MG.modifies_only_live_addresses
let loc_not_unused_in = MG.loc_not_unused_in _
let loc_unused_in = MG.loc_unused_in _
let loc_regions_unused_in = MG.loc_regions_unused_in cls | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(ensures
LowStar.Monotonic.Buffer.loc_disjoint (LowStar.Monotonic.Buffer.loc_unused_in h)
(LowStar.Monotonic.Buffer.loc_not_unused_in h)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_unused_in_not_unused_in_disjoint",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let loc_unused_in_not_unused_in_disjoint =
| MG.loc_unused_in_not_unused_in_disjoint cls | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.spred_as_mempred | val spred_as_mempred (#a: Type0) (#rrel #rel: srel a) (b: mbuffer a rrel rel) (p: spred a)
: HST.mem_predicate | val spred_as_mempred (#a: Type0) (#rrel #rel: srel a) (b: mbuffer a rrel rel) (p: spred a)
: HST.mem_predicate | let spred_as_mempred (#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel) (p:spred a)
:HST.mem_predicate
= fun h ->
buffer_compatible b ==>
p (as_seq h b) | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 1403,
"start_col": 8,
"start_line": 1399
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options
let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h'
let does_not_contain_addr = MG.does_not_contain_addr
let not_live_region_does_not_contain_addr = MG.not_live_region_does_not_contain_addr
let unused_in_does_not_contain_addr = MG.unused_in_does_not_contain_addr
let addr_unused_in_does_not_contain_addr = MG.addr_unused_in_does_not_contain_addr
let free_does_not_contain_addr = MG.free_does_not_contain_addr
let does_not_contain_addr_elim = MG.does_not_contain_addr_elim
let modifies_only_live_addresses = MG.modifies_only_live_addresses
let loc_not_unused_in = MG.loc_not_unused_in _
let loc_unused_in = MG.loc_unused_in _
let loc_regions_unused_in = MG.loc_regions_unused_in cls
let loc_unused_in_not_unused_in_disjoint =
MG.loc_unused_in_not_unused_in_disjoint cls
let not_live_region_loc_not_unused_in_disjoint = MG.not_live_region_loc_not_unused_in_disjoint cls
let live_loc_not_unused_in #_ #_ #_ b h =
unused_in_equiv b h;
Classical.move_requires (MG.does_not_contain_addr_addr_unused_in h) (frameOf b, as_addr b);
MG.loc_addresses_not_unused_in cls (frameOf b) (Set.singleton (as_addr b)) h;
()
let unused_in_loc_unused_in #_ #_ #_ b h =
unused_in_equiv b h;
Classical.move_requires (MG.addr_unused_in_does_not_contain_addr h) (frameOf b, as_addr b);
MG.loc_addresses_unused_in cls (frameOf b) (Set.singleton (as_addr b)) h;
()
let modifies_address_liveness_insensitive_unused_in =
MG.modifies_address_liveness_insensitive_unused_in cls
let modifies_only_not_unused_in = MG.modifies_only_not_unused_in
let mreference_live_loc_not_unused_in =
MG.mreference_live_loc_not_unused_in cls
let mreference_unused_in_loc_unused_in =
MG.mreference_unused_in_loc_unused_in cls
let modifies_loc_unused_in l h1 h2 l' =
modifies_loc_includes address_liveness_insensitive_locs h1 h2 l;
modifies_address_liveness_insensitive_unused_in h1 h2;
loc_includes_trans (loc_unused_in h1) (loc_unused_in h2) l'
let fresh_frame_modifies h0 h1 = MG.fresh_frame_modifies #_ cls h0 h1
let popped_modifies = MG.popped_modifies #_ cls
let modifies_remove_new_locs l_fresh l_aux l_goal h1 h2 h3 =
modifies_only_not_unused_in l_goal h1 h3
let disjoint_neq #_ #_ #_ #_ #_ #_ b1 b2 =
if frameOf b1 = frameOf b2 && as_addr b1 = as_addr b2 then
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
else ()
let empty_disjoint
#t1 #t2 #rrel1 #rel1 #rrel2 #rel2 b1 b2
= let r = frameOf b1 in
let a = as_addr b1 in
if r = frameOf b2 && a = as_addr b2 then
MG.loc_disjoint_aloc_intro #_ #cls #r #a #r #a (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
else ()
(*
let includes_live #a #rrel #rel1 #rel2 h larger smaller =
if Null? larger || Null? smaller then ()
else
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller)
*)
let includes_frameOf_as_addr #_ #_ #_ #_ #_ #_ larger smaller =
if Null? larger || Null? smaller then ()
else
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller)
let pointer_distinct_sel_disjoint #a #_ #_ #_ #_ b1 b2 h =
if frameOf b1 = frameOf b2 && as_addr b1 = as_addr b2
then begin
HS.mreference_distinct_sel_disjoint h (Buffer?.content b1) (Buffer?.content b2);
loc_disjoint_buffer b1 b2
end
else
loc_disjoint_buffer b1 b2
let is_null #_ #_ #_ b = Null? b
let msub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content i0 len0 ->
Buffer max_len content (U32.add i0 i) len
let moffset #a #rrel #rel sub_rel b i =
match b with
| Null -> Null
| Buffer max_len content i0 len ->
Buffer max_len content (U32.add i0 i) (Ghost.hide ((U32.sub (Ghost.reveal len) i)))
let index #_ #_ #_ b i =
let open HST in
let s = ! (Buffer?.content b) in
Seq.index s (U32.v (Buffer?.idx b) + U32.v i)
let g_upd_seq #_ #_ #_ b s h =
if Seq.length s = 0 then h
else
let s0 = HS.sel h (Buffer?.content b) in
let Buffer _ content idx length = b in
HS.upd h (Buffer?.content b) (Seq.replace_subseq s0 (U32.v idx) (U32.v idx + U32.v length) s)
let lemma_g_upd_with_same_seq #_ #_ #_ b h =
if Null? b then ()
else
let open FStar.UInt32 in
let Buffer _ content idx length = b in
let s = HS.sel h content in
assert (Seq.equal (Seq.replace_subseq s (v idx) (v idx + v length) (Seq.slice s (v idx) (v idx + v length))) s);
HS.lemma_heap_equality_upd_with_sel h (Buffer?.content b)
#push-options "--z3rlimit 48"
let g_upd_seq_as_seq #a #_ #_ b s h =
let h' = g_upd_seq b s h in
if g_is_null b then assert (Seq.equal s Seq.empty)
else begin
assert (Seq.equal (as_seq h' b) s);
// prove modifies_1_preserves_ubuffers
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
s_lemma_equal_instances_implies_equal_types ();
modifies_1_modifies b h h'
end
let g_upd_modifies_strong #_ #_ #_ b i v h =
let h' = g_upd b i v h in
// prove modifies_1_from_to_preserves_ubuffers
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
s_lemma_equal_instances_implies_equal_types ();
modifies_1_from_to_modifies b (U32.uint_to_t i) (U32.uint_to_t (i + 1)) h h'
#pop-options
let upd' #_ #_ #_ b i v =
let open HST in
let h = get() in
let Buffer max_length content idx len = b in
let s0 = !content in
let sb0 = Seq.slice s0 (U32.v idx) (U32.v max_length) in
let s_upd = Seq.upd sb0 (U32.v i) v in
let sf = Seq.replace_subseq s0 (U32.v idx) (U32.v max_length) s_upd in
assert (sf `Seq.equal`
Seq.replace_subseq s0 (U32.v idx) (U32.v idx + U32.v len) (Seq.upd (as_seq h b) (U32.v i) v));
content := sf
let recallable (#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel) :GTot Type0 =
(not (g_is_null b)) ==> (
HST.is_eternal_region (frameOf b) /\
not (HS.is_mm (Buffer?.content b)) /\
buffer_compatible b
)
let region_lifetime_buf #_ #_ #_ b =
(not (g_is_null b)) ==> (
HS.is_heap_color (HS.color (frameOf b)) /\
not (HS.is_mm (Buffer?.content b)) /\
buffer_compatible b
)
let region_lifetime_sub #a #rrel #rel #subrel b0 b1 =
match b1 with
| Null -> ()
| Buffer max_len content idx length ->
assert (forall (len:nat) (i:nat) (j:nat{i <= j /\ j <= len}). compatible_sub_preorder len rrel i j subrel)
let recallable_null #_ #_ #_ = ()
let recallable_mgsub #_ #rrel #rel b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
(*
let recallable_includes #_ #_ #_ #_ #_ #_ larger smaller =
if Null? larger || Null? smaller then ()
else
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller)
*)
let recall #_ #_ #_ b = if Null? b then () else HST.recall (Buffer?.content b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: LowStar.Monotonic.Buffer.mbuffer a rrel rel -> p: LowStar.Monotonic.Buffer.spred a
-> FStar.HyperStack.ST.mem_predicate | Prims.Tot | [
"total"
] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Monotonic.Buffer.spred",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_imp",
"LowStar.Monotonic.Buffer.buffer_compatible",
"LowStar.Monotonic.Buffer.as_seq",
"FStar.HyperStack.ST.mem_predicate"
] | [] | false | false | false | false | false | let spred_as_mempred (#a: Type0) (#rrel #rel: srel a) (b: mbuffer a rrel rel) (p: spred a)
: HST.mem_predicate =
| fun h -> buffer_compatible b ==> p (as_seq h b) | false |
LowStar.Monotonic.Buffer.fst | LowStar.Monotonic.Buffer.modifies_address_liveness_insensitive_unused_in | val modifies_address_liveness_insensitive_unused_in
(h h' : HS.mem)
: Lemma
(requires (modifies (address_liveness_insensitive_locs) h h'))
(ensures (loc_not_unused_in h' `loc_includes` loc_not_unused_in h /\ loc_unused_in h `loc_includes` loc_unused_in h')) | val modifies_address_liveness_insensitive_unused_in
(h h' : HS.mem)
: Lemma
(requires (modifies (address_liveness_insensitive_locs) h h'))
(ensures (loc_not_unused_in h' `loc_includes` loc_not_unused_in h /\ loc_unused_in h `loc_includes` loc_unused_in h')) | let modifies_address_liveness_insensitive_unused_in =
MG.modifies_address_liveness_insensitive_unused_in cls | {
"file_name": "ulib/LowStar.Monotonic.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 1235,
"start_col": 0,
"start_line": 1234
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
private let srel_to_lsrel (#a:Type0) (len:nat) (pre:srel a) :P.preorder (Seq.lseq a len) = pre
(*
* Counterpart of compatible_sub from the fsti but using sequences
*
* The patterns are guarded tightly, the proof of transitivity gets quite flaky otherwise
* The cost is that we have to additional asserts as triggers
*)
let compatible_sub_preorder (#a:Type0)
(len:nat) (rel:srel a) (i:nat) (j:nat{i <= j /\ j <= len}) (sub_rel:srel a)
= compatible_subseq_preorder len rel i j sub_rel
(*
* Reflexivity of the compatibility relation
*)
let lemma_seq_sub_compatilibity_is_reflexive (#a:Type0) (len:nat) (rel:srel a)
:Lemma (compatible_sub_preorder len rel 0 len rel)
= assert (forall (s1 s2:Seq.seq a). Seq.length s1 == Seq.length s2 ==>
Seq.equal (Seq.replace_subseq s1 0 (Seq.length s1) s2) s2)
(*
* Transitivity of the compatibility relation
*
* i2 and j2 are relative offsets within [i1, j1) (i.e. assuming i1 = 0)
*)
let lemma_seq_sub_compatibility_is_transitive (#a:Type0)
(len:nat) (rel:srel a) (i1 j1:nat) (rel1:srel a) (i2 j2:nat) (rel2:srel a)
:Lemma (requires (i1 <= j1 /\ j1 <= len /\ i2 <= j2 /\ j2 <= j1 - i1 /\
compatible_sub_preorder len rel i1 j1 rel1 /\
compatible_sub_preorder (j1 - i1) rel1 i2 j2 rel2))
(ensures (compatible_sub_preorder len rel (i1 + i2) (i1 + j2) rel2))
= let t1 (s1 s2:Seq.seq a) = Seq.length s1 == len /\ Seq.length s2 == len /\ rel s1 s2 in
let t2 (s1 s2:Seq.seq a) = t1 s1 s2 /\ rel2 (Seq.slice s1 (i1 + i2) (i1 + j2)) (Seq.slice s2 (i1 + i2) (i1 + j2)) in
let aux0 (s1 s2:Seq.seq a) :Lemma (t1 s1 s2 ==> t2 s1 s2)
= Classical.arrow_to_impl #(t1 s1 s2) #(t2 s1 s2)
(fun _ ->
assert (rel1 (Seq.slice s1 i1 j1) (Seq.slice s2 i1 j1));
assert (rel2 (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice (Seq.slice s2 i1 j1) i2 j2));
assert (Seq.equal (Seq.slice (Seq.slice s1 i1 j1) i2 j2) (Seq.slice s1 (i1 + i2) (i1 + j2)));
assert (Seq.equal (Seq.slice (Seq.slice s2 i1 j1) i2 j2) (Seq.slice s2 (i1 + i2) (i1 + j2))))
in
let t1 (s s2:Seq.seq a) = Seq.length s == len /\ Seq.length s2 == j2 - i2 /\
rel2 (Seq.slice s (i1 + i2) (i1 + j2)) s2 in
let t2 (s s2:Seq.seq a) = t1 s s2 /\ rel s (Seq.replace_subseq s (i1 + i2) (i1 + j2) s2) in
let aux1 (s s2:Seq.seq a) :Lemma (t1 s s2 ==> t2 s s2)
= Classical.arrow_to_impl #(t1 s s2) #(t2 s s2)
(fun _ ->
assert (Seq.equal (Seq.slice s (i1 + i2) (i1 + j2)) (Seq.slice (Seq.slice s i1 j1) i2 j2));
assert (rel1 (Seq.slice s i1 j1) (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2));
assert (rel s (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2)));
assert (Seq.equal (Seq.replace_subseq s i1 j1 (Seq.replace_subseq (Seq.slice s i1 j1) i2 j2 s2))
(Seq.replace_subseq s (i1 + i2) (i1 + j2) s2)))
in
Classical.forall_intro_2 aux0; Classical.forall_intro_2 aux1
noeq type mbuffer (a:Type0) (rrel:srel a) (rel:srel a) :Type0 =
| Null
| Buffer:
max_length:U32.t ->
content:HST.mreference (Seq.lseq a (U32.v max_length)) (srel_to_lsrel (U32.v max_length) rrel) ->
idx:U32.t ->
length:Ghost.erased U32.t{U32.v idx + U32.v (Ghost.reveal length) <= U32.v max_length} ->
mbuffer a rrel rel
let g_is_null #_ #_ #_ b = Null? b
let mnull #_ #_ #_ = Null
let null_unique #_ #_ #_ _ = ()
let unused_in #_ #_ #_ b h =
match b with
| Null -> False
| Buffer _ content _ _ -> content `HS.unused_in` h
let buffer_compatible (#t: Type) (#rrel #rel: srel t) (b: mbuffer t rrel rel) : GTot Type0 =
match b with
| Null -> True
| Buffer max_length content idx length ->
compatible_sub_preorder (U32.v max_length) rrel
(U32.v idx) (U32.v idx + U32.v length) rel //proof of compatibility
let live #_ #rrel #rel h b =
match b with
| Null -> True
| Buffer max_length content idx length ->
h `HS.contains` content /\
buffer_compatible b
let live_null _ _ _ _ = ()
let live_not_unused_in #_ #_ #_ _ _ = ()
let lemma_live_equal_mem_domains #_ #_ #_ _ _ _ = ()
let frameOf #_ #_ #_ b = if Null? b then HS.root else HS.frameOf (Buffer?.content b)
let as_addr #_ #_ #_ b = if g_is_null b then 0 else HS.as_addr (Buffer?.content b)
let unused_in_equiv #_ #_ #_ b h =
if g_is_null b then Heap.not_addr_unused_in_nullptr (Map.sel (HS.get_hmap h) HS.root) else ()
let live_region_frameOf #_ #_ #_ _ _ = ()
let len #_ #_ #_ b =
match b with
| Null -> 0ul
| Buffer _ _ _ len -> len
let len_null a _ _ = ()
let as_seq #_ #_ #_ h b =
match b with
| Null -> Seq.empty
| Buffer max_len content idx len ->
Seq.slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len)
let length_as_seq #_ #_ #_ _ _ = ()
let mbuffer_injectivity_in_first_preorder () = ()
let mgsub #a #rrel #rel sub_rel b i len =
match b with
| Null -> Null
| Buffer max_len content idx length ->
Buffer max_len content (U32.add idx i) (Ghost.hide len)
let live_gsub #_ #rrel #rel _ b i len sub_rel =
match b with
| Null -> ()
| Buffer max_len content idx length ->
let prf () : Lemma
(requires (buffer_compatible b))
(ensures (buffer_compatible (mgsub sub_rel b i len)))
=
lemma_seq_sub_compatibility_is_transitive (U32.v max_len) rrel
(U32.v idx) (U32.v idx + U32.v length) rel
(U32.v i) (U32.v i + U32.v len) sub_rel
in
Classical.move_requires prf ()
let gsub_is_null #_ #_ #_ _ _ _ _ = ()
let len_gsub #_ #_ #_ _ _ _ _ = ()
let frameOf_gsub #_ #_ #_ _ _ _ _ = ()
let as_addr_gsub #_ #_ #_ _ _ _ _ = ()
let mgsub_inj #_ #_ #_ _ _ _ _ _ _ _ _ = ()
#push-options "--z3rlimit 20"
let gsub_gsub #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let prf () : Lemma
(requires (compatible_sub b i1 len1 sub_rel1 /\ compatible_sub (mgsub sub_rel1 b i1 len1) i2 len2 sub_rel2))
(ensures (compatible_sub b (U32.add i1 i2) len2 sub_rel2))
=
lemma_seq_sub_compatibility_is_transitive (length b) rel (U32.v i1) (U32.v i1 + U32.v len1) sub_rel1
(U32.v i2) (U32.v i2 + U32.v len2) sub_rel2
in
Classical.move_requires prf ()
#pop-options
/// A buffer ``b`` is equal to its "largest" sub-buffer, at index 0 and
/// length ``len b``.
let gsub_zero_length #_ #_ #rel b = lemma_seq_sub_compatilibity_is_reflexive (length b) rel
let as_seq_gsub #_ #_ #_ h b i len _ =
match b with
| Null -> ()
| Buffer _ content idx len0 ->
Seq.slice_slice (HS.sel h content) (U32.v idx) (U32.v idx + U32.v len0) (U32.v i) (U32.v i + U32.v len)
let lemma_equal_instances_implies_equal_types (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b)
: Lemma (requires s1 === s2)
(ensures a == b)
= Seq.lemma_equal_instances_implies_equal_types ()
let s_lemma_equal_instances_implies_equal_types (_:unit)
: Lemma (forall (a:Type) (b:Type) (s1:Seq.seq a) (s2:Seq.seq b).
{:pattern (has_type s1 (Seq.seq a));
(has_type s2 (Seq.seq b)) }
s1 === s2 ==> a == b)
= Seq.lemma_equal_instances_implies_equal_types()
let live_same_addresses_equal_types_and_preorders'
(#a1 #a2: Type0)
(#rrel1 #rel1: srel a1)
(#rrel2 #rel2: srel a2)
(b1: mbuffer a1 rrel1 rel1)
(b2: mbuffer a2 rrel2 rel2)
(h: HS.mem)
: Lemma
(requires
frameOf b1 == frameOf b2 /\
as_addr b1 == as_addr b2 /\
live h b1 /\
live h b2 /\
(~ (g_is_null b1 /\ g_is_null b2)))
(ensures
a1 == a2 /\
rrel1 == rrel2)
= Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
let s1 : Seq.seq a1 = as_seq h b1 in
assert (Seq.seq a1 == Seq.seq a2);
let s1' : Seq.seq a2 = coerce_eq _ s1 in
assert (s1 === s1');
lemma_equal_instances_implies_equal_types a1 a2 s1 s1'
let live_same_addresses_equal_types_and_preorders
#_ #_ #_ #_ #_ #_ b1 b2 h
= Classical.move_requires (live_same_addresses_equal_types_and_preorders' b1 b2) h
(* Untyped view of buffers, used only to implement the generic modifies clause. DO NOT USE in client code. *)
noeq
type ubuffer_
: Type0
= {
b_max_length: nat;
b_offset: nat;
b_length: nat;
b_is_mm: bool;
}
val ubuffer' (region: HS.rid) (addr: nat) : Tot Type0
let ubuffer' region addr = (x: ubuffer_ { x.b_offset + x.b_length <= x.b_max_length } )
let ubuffer (region: HS.rid) (addr: nat) : Tot Type0 = G.erased (ubuffer' region addr)
let ubuffer_of_buffer' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel)
:Tot (ubuffer (frameOf b) (as_addr b))
= if Null? b
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
Ghost.hide ({
b_max_length = U32.v (Buffer?.max_length b);
b_offset = U32.v (Buffer?.idx b);
b_length = U32.v (Buffer?.length b);
b_is_mm = HS.is_mm (Buffer?.content b);
})
let ubuffer_preserved'
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h h' : HS.mem)
: GTot Type0
= forall (t':Type0) (rrel rel:srel t') (b':mbuffer t' rrel rel) .
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
val ubuffer_preserved (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h h' : HS.mem) : GTot Type0
let ubuffer_preserved = ubuffer_preserved'
let ubuffer_preserved_intro
(#r:HS.rid)
(#a:nat)
(b:ubuffer r a)
(h h' :HS.mem)
(f0: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (frameOf b' == r /\ as_addr b' == a /\ live h b'))
(ensures (live h' b'))
))
(f: (
(t':Type0) ->
(rrel:srel t') -> (rel:srel t') ->
(b':mbuffer t' rrel rel) ->
Lemma
(requires (
frameOf b' == r /\ as_addr b' == a /\
live h b' /\ live h' b' /\
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
))))
(ensures (
Buffer? b' /\ (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len /\
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))
))
: Lemma
(ubuffer_preserved b h h')
= let g'
(t':Type0) (rrel rel:srel t')
(b':mbuffer t' rrel rel)
: Lemma
((frameOf b' == r /\ as_addr b' == a) ==> (
(live h b' ==> live h' b') /\ (
((live h b' /\ live h' b' /\ Buffer? b') ==> (
let ({ b_max_length = bmax; b_offset = boff; b_length = blen }) = Ghost.reveal b in
let Buffer max _ idx len = b' in (
U32.v max == bmax /\
U32.v idx <= boff /\
boff + blen <= U32.v idx + U32.v len
) ==>
Seq.equal (Seq.slice (as_seq h b') (boff - U32.v idx) (boff - U32.v idx + blen)) (Seq.slice (as_seq h' b') (boff - U32.v idx) (boff - U32.v idx + blen))
)))))
= Classical.move_requires (f0 t' rrel rel) b';
Classical.move_requires (f t' rrel rel) b'
in
Classical.forall_intro_4 g'
val ubuffer_preserved_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h : HS.mem) : Lemma
(ubuffer_preserved b h h)
let ubuffer_preserved_refl #r #a b h = ()
val ubuffer_preserved_trans (#r: HS.rid) (#a: nat) (b: ubuffer r a) (h1 h2 h3 : HS.mem) : Lemma
(requires (ubuffer_preserved b h1 h2 /\ ubuffer_preserved b h2 h3))
(ensures (ubuffer_preserved b h1 h3))
let ubuffer_preserved_trans #r #a b h1 h2 h3 = ()
val same_mreference_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
(f: (
(a' : Type) ->
(pre: Preorder.preorder a') ->
(r': HS.mreference a' pre) ->
Lemma
(requires (h1 `HS.contains` r' /\ r == HS.frameOf r' /\ a == HS.as_addr r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
))
: Lemma
(ubuffer_preserved b h1 h2)
let same_mreference_ubuffer_preserved #r #a b h1 h2 f =
ubuffer_preserved_intro b h1 h2
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
(fun t' _ _ b' ->
if Null? b'
then ()
else
f _ _ (Buffer?.content b')
)
val addr_unused_in_ubuffer_preserved
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (HS.live_region h1 r ==> a `Heap.addr_unused_in` (Map.sel (HS.get_hmap h1) r)))
(ensures (ubuffer_preserved b h1 h2))
let addr_unused_in_ubuffer_preserved #r #a b h1 h2 = ()
val ubuffer_of_buffer (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) :Tot (ubuffer (frameOf b) (as_addr b))
let ubuffer_of_buffer #_ #_ #_ b = ubuffer_of_buffer' b
let ubuffer_of_buffer_from_to_none_cond
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot bool
= g_is_null b || U32.v to < U32.v from || U32.v from > length b
let ubuffer_of_buffer_from_to
#a #rrel #rel (b: mbuffer a rrel rel) from to
: GTot (ubuffer (frameOf b) (as_addr b))
= if ubuffer_of_buffer_from_to_none_cond b from to
then
Ghost.hide ({
b_max_length = 0;
b_offset = 0;
b_length = 0;
b_is_mm = false;
})
else
let to' = if U32.v to > length b then length b else U32.v to in
let b1 = ubuffer_of_buffer b in
Ghost.hide ({ Ghost.reveal b1 with b_offset = (Ghost.reveal b1).b_offset + U32.v from; b_length = to' - U32.v from })
val ubuffer_preserved_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h h':HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h' /\ live h b))
(ensures (live h' b /\ as_seq h b == as_seq h' b))
let ubuffer_preserved_elim #_ #_ #_ _ _ _ = ()
val ubuffer_preserved_from_to_elim (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h h' : HS.mem)
:Lemma (requires (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) h h' /\ live h b))
(ensures (live h' b /\ ((U32.v from <= U32.v to /\ U32.v to <= length b) ==> Seq.slice (as_seq h b) (U32.v from) (U32.v to) == Seq.slice (as_seq h' b) (U32.v from) (U32.v to))))
let ubuffer_preserved_from_to_elim #_ #_ #_ _ _ _ _ _ = ()
let unused_in_ubuffer_preserved (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h h':HS.mem)
: Lemma (requires (b `unused_in` h))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'))
= Classical.move_requires (fun b -> live_not_unused_in h b) b;
live_null a rrel rel h;
null_unique b;
unused_in_equiv b h;
addr_unused_in_ubuffer_preserved #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) h h'
let ubuffer_includes' (larger smaller: ubuffer_) : GTot Type0 =
larger.b_is_mm == smaller.b_is_mm /\
larger.b_max_length == smaller.b_max_length /\
larger.b_offset <= smaller.b_offset /\
smaller.b_offset + smaller.b_length <= larger.b_offset + larger.b_length
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_includes0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (larger:ubuffer r1 a1) (smaller:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\ ubuffer_includes' (G.reveal larger) (G.reveal smaller)
val ubuffer_includes (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) : GTot Type0
let ubuffer_includes #r #a larger smaller = ubuffer_includes0 larger smaller
val ubuffer_includes_refl (#r: HS.rid) (#a: nat) (b: ubuffer r a) : Lemma
(b `ubuffer_includes` b)
let ubuffer_includes_refl #r #a b = ()
val ubuffer_includes_trans (#r: HS.rid) (#a: nat) (b1 b2 b3: ubuffer r a) : Lemma
(requires (b1 `ubuffer_includes` b2 /\ b2 `ubuffer_includes` b3))
(ensures (b1 `ubuffer_includes` b3))
let ubuffer_includes_trans #r #a b1 b2 b3 = ()
(*
* TODO: not sure how to make this lemma work with preorders
* it creates a buffer larger' in the proof
* we need a compatible preorder for that
* may be take that as an argument?
*)
(*val ubuffer_includes_ubuffer_preserved (#r: HS.rid) (#a: nat) (larger smaller: ubuffer r a) (h1 h2: HS.mem) : Lemma
(requires (larger `ubuffer_includes` smaller /\ ubuffer_preserved larger h1 h2))
(ensures (ubuffer_preserved smaller h1 h2))
let ubuffer_includes_ubuffer_preserved #r #a larger smaller h1 h2 =
ubuffer_preserved_intro smaller h1 h2 (fun t' b' ->
if Null? b'
then ()
else
let (Buffer max_len content idx' len') = b' in
let idx = U32.uint_to_t (G.reveal larger).b_offset in
let len = U32.uint_to_t (G.reveal larger).b_length in
let larger' = Buffer max_len content idx len in
assert (b' == gsub larger' (U32.sub idx' idx) len');
ubuffer_preserved_elim larger' h1 h2
)*)
let ubuffer_disjoint' (x1 x2: ubuffer_) : GTot Type0 =
if x1.b_length = 0 || x2.b_length = 0
then True
else
(x1.b_max_length == x2.b_max_length /\
(x1.b_offset + x1.b_length <= x2.b_offset \/
x2.b_offset + x2.b_length <= x1.b_offset))
(* TODO: added this because of #606, now that it is fixed, we may not need it anymore *)
let ubuffer_disjoint0 (#r1 #r2:HS.rid) (#a1 #a2:nat) (b1:ubuffer r1 a1) (b2:ubuffer r2 a2) =
r1 == r2 /\ a1 == a2 /\
ubuffer_disjoint' (G.reveal b1) (G.reveal b2)
val ubuffer_disjoint (#r:HS.rid) (#a:nat) (b1 b2:ubuffer r a) :GTot Type0
let ubuffer_disjoint #r #a b1 b2 = ubuffer_disjoint0 b1 b2
val ubuffer_disjoint_sym (#r:HS.rid) (#a: nat) (b1 b2:ubuffer r a)
:Lemma (ubuffer_disjoint b1 b2 <==> ubuffer_disjoint b2 b1)
let ubuffer_disjoint_sym #_ #_ b1 b2 = ()
val ubuffer_disjoint_includes (#r: HS.rid) (#a: nat) (larger1 larger2: ubuffer r a) (smaller1 smaller2: ubuffer r a) : Lemma
(requires (ubuffer_disjoint larger1 larger2 /\ larger1 `ubuffer_includes` smaller1 /\ larger2 `ubuffer_includes` smaller2))
(ensures (ubuffer_disjoint smaller1 smaller2))
let ubuffer_disjoint_includes #r #a larger1 larger2 smaller1 smaller2 = ()
val liveness_preservation_intro (#a:Type0) (#rrel:srel a) (#rel:srel a)
(h h':HS.mem) (b:mbuffer a rrel rel)
(f: (
(t':Type0) ->
(pre: Preorder.preorder t') ->
(r: HS.mreference t' pre) ->
Lemma
(requires (HS.frameOf r == frameOf b /\ HS.as_addr r == as_addr b /\ h `HS.contains` r))
(ensures (h' `HS.contains` r))
))
:Lemma (requires (live h b)) (ensures (live h' b))
let liveness_preservation_intro #_ #_ #_ _ _ b f =
if Null? b
then ()
else f _ _ (Buffer?.content b)
(* Basic, non-compositional modifies clauses, used only to implement the generic modifies clause. DO NOT USE in client code *)
let modifies_0_preserves_mreferences (h1 h2: HS.mem) : GTot Type0 =
forall (a: Type) (pre: Preorder.preorder a) (r: HS.mreference a pre) .
h1 `HS.contains` r ==> (h2 `HS.contains` r /\ HS.sel h1 r == HS.sel h2 r)
let modifies_0_preserves_regions (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) . HS.live_region h1 r ==> HS.live_region h2 r
let modifies_0_preserves_not_unused_in (h1 h2: HS.mem) : GTot Type0 =
forall (r: HS.rid) (n: nat) . (
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
) ==> (
n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)
)
let modifies_0' (h1 h2: HS.mem) : GTot Type0 =
modifies_0_preserves_mreferences h1 h2 /\
modifies_0_preserves_regions h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2
val modifies_0 (h1 h2: HS.mem) : GTot Type0
let modifies_0 = modifies_0'
val modifies_0_live_region (h1 h2: HS.mem) (r: HS.rid) : Lemma
(requires (modifies_0 h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_0_live_region h1 h2 r = ()
val modifies_0_mreference (#a: Type) (#pre: Preorder.preorder a) (h1 h2: HS.mem) (r: HS.mreference a pre) : Lemma
(requires (modifies_0 h1 h2 /\ h1 `HS.contains` r))
(ensures (h2 `HS.contains` r /\ h1 `HS.sel` r == h2 `HS.sel` r))
let modifies_0_mreference #a #pre h1 h2 r = ()
let modifies_0_ubuffer
(#r: HS.rid)
(#a: nat)
(b: ubuffer r a)
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (ubuffer_preserved b h1 h2))
= same_mreference_ubuffer_preserved b h1 h2 (fun a' pre r' -> modifies_0_mreference h1 h2 r')
val modifies_0_unused_in
(h1 h2: HS.mem)
(r: HS.rid)
(n: nat)
: Lemma
(requires (
modifies_0 h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)
))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_0_unused_in h1 h2 r n = ()
let modifies_1_preserves_mreferences (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre).
((frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r') ==>
(h2 `HS.contains` r' /\ HS.sel h1 r' == HS.sel h2 r')
let modifies_1_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_from_to_preserves_ubuffers (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= forall (b':ubuffer (frameOf b) (as_addr b)).
(ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b') ==> ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2
let modifies_1_preserves_livenesses (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= forall (a':Type) (pre:Preorder.preorder a') (r':HS.mreference a' pre). h1 `HS.contains` r' ==> h2 `HS.contains` r'
let modifies_1' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
: GTot Type0
= modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_preserves_ubuffers b h1 h2
val modifies_1 (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_1 = modifies_1'
let modifies_1_from_to (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
: GTot Type0
= if ubuffer_of_buffer_from_to_none_cond b from to
then modifies_0 h1 h2
else
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_1_preserves_livenesses b h1 h2 /\
modifies_0_preserves_not_unused_in h1 h2 /\
modifies_1_from_to_preserves_ubuffers b from to h1 h2
val modifies_1_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1 b h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
let modifies_1_live_region #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ HS.live_region h1 r)) (ensures (HS.live_region h2 r))
= ()
val modifies_1_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1 b h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
let modifies_1_liveness #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_liveness
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\ h1 `HS.contains` r')) (ensures (h2 `HS.contains` r'))
= ()
val modifies_1_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1 b h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_1_unused_in #_ #_ #_ _ _ _ _ _ = ()
let modifies_1_from_to_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
:Lemma (requires (modifies_1_from_to b from to h1 h2 /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
= ()
val modifies_1_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1 b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_1_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
let modifies_1_from_to_mreference
(#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r': HS.mreference a' pre)
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
= ()
val modifies_1_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1 b h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
let modifies_1_ubuffer #_ #_ #_ _ _ _ _ = ()
let modifies_1_from_to_ubuffer (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem) (b':ubuffer (frameOf b) (as_addr b))
: Lemma (requires (modifies_1_from_to b from to h1 h2 /\ ubuffer_disjoint #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) b'))
(ensures (ubuffer_preserved #(frameOf b) #(as_addr b) b' h1 h2))
= ()
val modifies_1_null (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
: Lemma (requires (modifies_1 b h1 h2 /\ g_is_null b))
(ensures (modifies_0 h1 h2))
let modifies_1_null #_ #_ #_ _ _ _ = ()
let modifies_addr_of_preserves_not_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem)
:GTot Type0
= forall (r: HS.rid) (n: nat) .
((r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)) ==>
(n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r))
let modifies_addr_of' (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0 =
modifies_0_preserves_regions h1 h2 /\
modifies_1_preserves_mreferences b h1 h2 /\
modifies_addr_of_preserves_not_unused_in b h1 h2
val modifies_addr_of (#a:Type0) (#rrel:srel a) (#rel:srel a) (b:mbuffer a rrel rel) (h1 h2:HS.mem) :GTot Type0
let modifies_addr_of = modifies_addr_of'
val modifies_addr_of_live_region (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid)
:Lemma (requires (modifies_addr_of b h1 h2 /\ HS.live_region h1 r))
(ensures (HS.live_region h2 r))
let modifies_addr_of_live_region #_ #_ #_ _ _ _ _ = ()
val modifies_addr_of_mreference (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
(#a':Type0) (#pre:Preorder.preorder a') (r':HS.mreference a' pre)
: Lemma (requires (modifies_addr_of b h1 h2 /\ (frameOf b <> HS.frameOf r' \/ as_addr b <> HS.as_addr r') /\ h1 `HS.contains` r'))
(ensures (h2 `HS.contains` r' /\ h1 `HS.sel` r' == h2 `HS.sel` r'))
let modifies_addr_of_mreference #_ #_ #_ _ _ _ #_ #_ _ = ()
val modifies_addr_of_unused_in (#a:Type0) (#rrel:srel a) (#rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem) (r:HS.rid) (n:nat)
: Lemma (requires (modifies_addr_of b h1 h2 /\
(r <> frameOf b \/ n <> as_addr b) /\
HS.live_region h1 r /\ HS.live_region h2 r /\
n `Heap.addr_unused_in` (HS.get_hmap h2 `Map.sel` r)))
(ensures (n `Heap.addr_unused_in` (HS.get_hmap h1 `Map.sel` r)))
let modifies_addr_of_unused_in #_ #_ #_ _ _ _ _ _ = ()
module MG = FStar.ModifiesGen
let cls : MG.cls ubuffer = MG.Cls #ubuffer
ubuffer_includes
(fun #r #a x -> ubuffer_includes_refl x)
(fun #r #a x1 x2 x3 -> ubuffer_includes_trans x1 x2 x3)
ubuffer_disjoint
(fun #r #a x1 x2 -> ubuffer_disjoint_sym x1 x2)
(fun #r #a larger1 larger2 smaller1 smaller2 -> ubuffer_disjoint_includes larger1 larger2 smaller1 smaller2)
ubuffer_preserved
(fun #r #a x h -> ubuffer_preserved_refl x h)
(fun #r #a x h1 h2 h3 -> ubuffer_preserved_trans x h1 h2 h3)
(fun #r #a b h1 h2 f -> same_mreference_ubuffer_preserved b h1 h2 f)
let loc = MG.loc cls
let _ = intro_ambient loc
let loc_none = MG.loc_none
let _ = intro_ambient loc_none
let loc_union = MG.loc_union
let _ = intro_ambient loc_union
let loc_union_idem = MG.loc_union_idem
let loc_union_comm = MG.loc_union_comm
let loc_union_assoc = MG.loc_union_assoc
let loc_union_loc_none_l = MG.loc_union_loc_none_l
let loc_union_loc_none_r = MG.loc_union_loc_none_r
let loc_buffer_from_to #a #rrel #rel b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then MG.loc_none
else
MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to)
let loc_buffer #_ #_ #_ b =
if g_is_null b then MG.loc_none
else MG.loc_of_aloc #_ #_ #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_buffer_eq #_ #_ #_ _ = ()
let loc_buffer_from_to_high #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_none #_ #_ #_ _ _ _ = ()
let loc_buffer_from_to_mgsub #_ #_ #_ _ _ _ _ _ _ = ()
let loc_buffer_mgsub_eq #_ #_ #_ _ _ _ _ = ()
let loc_buffer_null _ _ _ = ()
let loc_buffer_from_to_eq #_ #_ #_ _ _ _ = ()
let loc_buffer_mgsub_rel_eq #_ #_ #_ _ _ _ _ _ = ()
let loc_addresses = MG.loc_addresses
let loc_regions = MG.loc_regions
let loc_includes = MG.loc_includes
let loc_includes_refl = MG.loc_includes_refl
let loc_includes_trans = MG.loc_includes_trans
let loc_includes_union_r = MG.loc_includes_union_r
let loc_includes_union_l = MG.loc_includes_union_l
let loc_includes_none = MG.loc_includes_none
val loc_includes_buffer (#a:Type0) (#rrel1:srel a) (#rrel2:srel a) (#rel1:srel a) (#rel2:srel a)
(b1:mbuffer a rrel1 rel1) (b2:mbuffer a rrel2 rel2)
:Lemma (requires (frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2 /\
ubuffer_includes0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_includes (loc_buffer b1) (loc_buffer b2)))
let loc_includes_buffer #t #_ #_ #_ #_ b1 b2 =
let t1 = ubuffer (frameOf b1) (as_addr b1) in
MG.loc_includes_aloc #_ #cls #(frameOf b1) #(as_addr b1) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_includes_gsub_buffer_r l #_ #_ #_ b i len sub_rel =
let b' = mgsub sub_rel b i len in
loc_includes_buffer b b';
loc_includes_trans l (loc_buffer b) (loc_buffer b')
let loc_includes_gsub_buffer_l #_ #_ #rel b i1 len1 sub_rel1 i2 len2 sub_rel2 =
let b1 = mgsub sub_rel1 b i1 len1 in
let b2 = mgsub sub_rel2 b i2 len2 in
loc_includes_buffer b1 b2
let loc_includes_loc_buffer_loc_buffer_from_to #_ #_ #_ b from to =
if ubuffer_of_buffer_from_to_none_cond b from to
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) (ubuffer_of_buffer_from_to b from to)
let loc_includes_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_includes_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
#push-options "--z3rlimit 20"
let loc_includes_as_seq #_ #rrel #_ #_ h1 h2 larger smaller =
if Null? smaller then () else
if Null? larger then begin
MG.loc_includes_none_elim (loc_buffer smaller);
MG.loc_of_aloc_not_none #_ #cls #(frameOf smaller) #(as_addr smaller) (ubuffer_of_buffer smaller)
end else begin
MG.loc_includes_aloc_elim #_ #cls #(frameOf larger) #(frameOf smaller) #(as_addr larger) #(as_addr smaller) (ubuffer_of_buffer larger) (ubuffer_of_buffer smaller);
let ul = Ghost.reveal (ubuffer_of_buffer larger) in
let us = Ghost.reveal (ubuffer_of_buffer smaller) in
assert (as_seq h1 smaller == Seq.slice (as_seq h1 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller));
assert (as_seq h2 smaller == Seq.slice (as_seq h2 larger) (us.b_offset - ul.b_offset) (us.b_offset - ul.b_offset + length smaller))
end
#pop-options
let loc_includes_addresses_buffer #a #rrel #srel preserve_liveness r s p =
MG.loc_includes_addresses_aloc #_ #cls preserve_liveness r s #(as_addr p) (ubuffer_of_buffer p)
let loc_includes_region_buffer #_ #_ #_ preserve_liveness s b =
MG.loc_includes_region_aloc #_ #cls preserve_liveness s #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let loc_includes_region_addresses = MG.loc_includes_region_addresses #_ #cls
let loc_includes_region_region = MG.loc_includes_region_region #_ #cls
let loc_includes_region_union_l = MG.loc_includes_region_union_l
let loc_includes_addresses_addresses = MG.loc_includes_addresses_addresses cls
let loc_disjoint = MG.loc_disjoint
let loc_disjoint_sym = MG.loc_disjoint_sym
let loc_disjoint_none_r = MG.loc_disjoint_none_r
let loc_disjoint_union_r = MG.loc_disjoint_union_r
let loc_disjoint_includes = MG.loc_disjoint_includes
val loc_disjoint_buffer (#a1 #a2:Type0) (#rrel1 #rel1:srel a1) (#rrel2 #rel2:srel a2)
(b1:mbuffer a1 rrel1 rel1) (b2:mbuffer a2 rrel2 rel2)
:Lemma (requires ((frameOf b1 == frameOf b2 /\ as_addr b1 == as_addr b2) ==>
ubuffer_disjoint0 #(frameOf b1) #(frameOf b2) #(as_addr b1) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)))
(ensures (loc_disjoint (loc_buffer b1) (loc_buffer b2)))
let loc_disjoint_buffer #_ #_ #_ #_ #_ #_ b1 b2 =
MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b1) #(as_addr b1) #(frameOf b2) #(as_addr b2) (ubuffer_of_buffer b1) (ubuffer_of_buffer b2)
let loc_disjoint_gsub_buffer #_ #_ #_ b i1 len1 sub_rel1 i2 len2 sub_rel2 =
loc_disjoint_buffer (mgsub sub_rel1 b i1 len1) (mgsub sub_rel2 b i2 len2)
let loc_disjoint_loc_buffer_from_to #_ #_ #_ b from1 to1 from2 to2 =
if ubuffer_of_buffer_from_to_none_cond b from1 to1 || ubuffer_of_buffer_from_to_none_cond b from2 to2
then ()
else MG.loc_disjoint_aloc_intro #_ #cls #(frameOf b) #(as_addr b) #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from1 to1) (ubuffer_of_buffer_from_to b from2 to2)
let loc_disjoint_addresses = MG.loc_disjoint_addresses_intro #_ #cls
let loc_disjoint_regions = MG.loc_disjoint_regions #_ #cls
let modifies = MG.modifies
let modifies_live_region = MG.modifies_live_region
let modifies_mreference_elim = MG.modifies_mreference_elim
let modifies_buffer_elim #_ #_ #_ b p h h' =
if g_is_null b
then
assert (as_seq h b `Seq.equal` as_seq h' b)
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) p h h' ;
ubuffer_preserved_elim b h h'
end
let modifies_buffer_from_to_elim #_ #_ #_ b from to p h h' =
if g_is_null b
then ()
else begin
MG.modifies_aloc_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) p h h' ;
ubuffer_preserved_from_to_elim b from to h h'
end
let modifies_refl = MG.modifies_refl
let modifies_loc_includes = MG.modifies_loc_includes
let address_liveness_insensitive_locs = MG.address_liveness_insensitive_locs _
let region_liveness_insensitive_locs = MG.region_liveness_insensitive_locs _
let address_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_address_liveness_insensitive_locs_aloc #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let address_liveness_insensitive_addresses =
MG.loc_includes_address_liveness_insensitive_locs_addresses cls
let region_liveness_insensitive_buffer #_ #_ #_ b =
MG.loc_includes_region_liveness_insensitive_locs_loc_of_aloc #_ cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b)
let region_liveness_insensitive_addresses =
MG.loc_includes_region_liveness_insensitive_locs_loc_addresses cls
let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls
let region_liveness_insensitive_address_liveness_insensitive =
MG.loc_includes_region_liveness_insensitive_locs_address_liveness_insensitive_locs cls
let modifies_liveness_insensitive_mreference = MG.modifies_preserves_liveness
let modifies_liveness_insensitive_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else
liveness_preservation_intro h h' x (fun t' pre r ->
MG.modifies_preserves_liveness_strong l1 l2 h h' r (ubuffer_of_buffer x))
let modifies_liveness_insensitive_region = MG.modifies_preserves_region_liveness
let modifies_liveness_insensitive_region_mreference = MG.modifies_preserves_region_liveness_reference
let modifies_liveness_insensitive_region_buffer l1 l2 h h' #_ #_ #_ x =
if g_is_null x then ()
else MG.modifies_preserves_region_liveness_aloc l1 l2 h h' #(frameOf x) #(as_addr x) (ubuffer_of_buffer x)
let modifies_trans = MG.modifies_trans
let modifies_only_live_regions = MG.modifies_only_live_regions
let no_upd_fresh_region = MG.no_upd_fresh_region
let new_region_modifies = MG.new_region_modifies #_ cls
let modifies_fresh_frame_popped = MG.modifies_fresh_frame_popped
let modifies_loc_regions_intro = MG.modifies_loc_regions_intro #_ #cls
let modifies_loc_addresses_intro = MG.modifies_loc_addresses_intro #_ #cls
let modifies_ralloc_post = MG.modifies_ralloc_post #_ #cls
let modifies_salloc_post = MG.modifies_salloc_post #_ #cls
let modifies_free = MG.modifies_free #_ #cls
let modifies_none_modifies = MG.modifies_none_modifies #_ #cls
let modifies_upd = MG.modifies_upd #_ #cls
val modifies_0_modifies
(h1 h2: HS.mem)
: Lemma
(requires (modifies_0 h1 h2))
(ensures (modifies loc_none h1 h2))
let modifies_0_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun r -> modifies_0_live_region h1 h2 r)
(fun t pre b -> modifies_0_mreference #t #pre h1 h2 b)
(fun r n -> modifies_0_unused_in h1 h2 r n)
val modifies_1_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
let modifies_1_modifies #t #_ #_ b h1 h2 =
if g_is_null b
then begin
modifies_1_null b h1 h2;
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer b) h1 h2
(fun r -> modifies_1_live_region b h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer b) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_mreference b h1 h2 p
)
(fun t pre p ->
modifies_1_liveness b h1 h2 p
)
(fun r n ->
modifies_1_unused_in b h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer b);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer b) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_ubuffer #t b h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_mreference b h1 h2 r_)
)
val modifies_1_from_to_modifies
(#a:Type0)(#rrel #rel:srel a)
(b:mbuffer a rrel rel) (from to: U32.t) (h1 h2:HS.mem)
:Lemma (requires (modifies_1_from_to b from to h1 h2))
(ensures (modifies (loc_buffer_from_to b from to) h1 h2))
let modifies_1_from_to_modifies #t #_ #_ b from to h1 h2 =
if ubuffer_of_buffer_from_to_none_cond b from to
then begin
modifies_0_modifies h1 h2
end else
MG.modifies_intro (loc_buffer_from_to b from to) h1 h2
(fun r -> modifies_1_from_to_live_region b from to h1 h2 r)
(fun t pre p ->
loc_disjoint_sym (loc_mreference p) (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(frameOf b) #(as_addr b) (ubuffer_of_buffer_from_to b from to) true (HS.frameOf p) (Set.singleton (HS.as_addr p));
modifies_1_from_to_mreference b from to h1 h2 p
)
(fun t pre p ->
modifies_1_from_to_liveness b from to h1 h2 p
)
(fun r n ->
modifies_1_from_to_unused_in b from to h1 h2 r n
)
(fun r' a' b' ->
loc_disjoint_sym (MG.loc_of_aloc b') (loc_buffer_from_to b from to);
MG.loc_disjoint_aloc_elim #_ #cls #(frameOf b) #(as_addr b) #r' #a' (ubuffer_of_buffer_from_to b from to) b';
if frameOf b = r' && as_addr b = a'
then
modifies_1_from_to_ubuffer #t b from to h1 h2 b'
else
same_mreference_ubuffer_preserved #r' #a' b' h1 h2
(fun a_ pre_ r_ -> modifies_1_from_to_mreference b from to h1 h2 r_)
)
val modifies_addr_of_modifies
(#a:Type0) (#rrel #rel:srel a)
(b:mbuffer a rrel rel) (h1 h2:HS.mem)
:Lemma (requires (modifies_addr_of b h1 h2))
(ensures (modifies (loc_addr_of_buffer b) h1 h2))
let modifies_addr_of_modifies #t #_ #_ b h1 h2 =
MG.modifies_address_intro #_ #cls (frameOf b) (as_addr b) h1 h2
(fun r -> modifies_addr_of_live_region b h1 h2 r)
(fun t pre p ->
modifies_addr_of_mreference b h1 h2 p
)
(fun r n ->
modifies_addr_of_unused_in b h1 h2 r n
)
val modifies_loc_buffer_from_to_intro'
(#a:Type0) (#rrel #rel:srel a) (b:mbuffer a rrel rel)
(from to: U32.t)
(l: loc) (h h' : HS.mem)
: Lemma
(requires (
let s = as_seq h b in
let s' = as_seq h' b in
not (g_is_null b) /\
live h b /\
modifies (loc_union l (loc_buffer b)) h h' /\
U32.v from <= U32.v to /\
U32.v to <= length b /\
Seq.slice s 0 (U32.v from) `Seq.equal` Seq.slice s' 0 (U32.v from) /\
Seq.slice s (U32.v to) (length b) `Seq.equal` Seq.slice s' (U32.v to) (length b)
))
(ensures (modifies (loc_union l (loc_buffer_from_to b from to)) h h'))
#push-options "--z3rlimit 16"
let modifies_loc_buffer_from_to_intro' #a #rrel #rel b from to l h h' =
let r0 = frameOf b in
let a0 = as_addr b in
let bb : ubuffer r0 a0 = ubuffer_of_buffer b in
modifies_loc_includes (loc_union l (loc_addresses true r0 (Set.singleton a0))) h h' (loc_union l (loc_buffer b));
MG.modifies_strengthen l #r0 #a0 (ubuffer_of_buffer_from_to b from to) h h' (fun f (x: ubuffer r0 a0) ->
ubuffer_preserved_intro x h h'
(fun t' rrel' rel' b' -> f _ _ (Buffer?.content b'))
(fun t' rrel' rel' b' ->
// prove that the types, rrels, rels are equal
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
assert (Seq.seq t' == Seq.seq a);
let _s0 : Seq.seq a = as_seq h b in
let _s1 : Seq.seq t' = coerce_eq _ _s0 in
lemma_equal_instances_implies_equal_types a t' _s0 _s1;
let boff = U32.v (Buffer?.idx b) in
let from_ = boff + U32.v from in
let to_ = boff + U32.v to in
let ({ b_max_length = ml; b_offset = xoff; b_length = xlen; b_is_mm = is_mm }) = Ghost.reveal x in
let ({ b_max_length = _; b_offset = b'off; b_length = b'len }) = Ghost.reveal (ubuffer_of_buffer b') in
let bh = as_seq h b in
let bh' = as_seq h' b in
let xh = Seq.slice (as_seq h b') (xoff - b'off) (xoff - b'off + xlen) in
let xh' = Seq.slice (as_seq h' b') (xoff - b'off) (xoff - b'off + xlen) in
let prf (i: nat) : Lemma
(requires (i < xlen))
(ensures (i < xlen /\ Seq.index xh i == Seq.index xh' i))
= let xi = xoff + i in
let bi : ubuffer r0 a0 =
Ghost.hide ({ b_max_length = ml; b_offset = xi; b_length = 1; b_is_mm = is_mm; })
in
assert (Seq.index xh i == Seq.index (Seq.slice (as_seq h b') (xi - b'off) (xi - b'off + 1)) 0);
assert (Seq.index xh' i == Seq.index (Seq.slice (as_seq h' b') (xi - b'off) (xi - b'off + 1)) 0);
let li = MG.loc_of_aloc bi in
MG.loc_includes_aloc #_ #cls x bi;
loc_disjoint_includes l (MG.loc_of_aloc x) l li;
if xi < boff || boff + length b <= xi
then begin
MG.loc_disjoint_aloc_intro #_ #cls bb bi;
assert (loc_disjoint (loc_union l (loc_buffer b)) li);
MG.modifies_aloc_elim bi (loc_union l (loc_buffer b)) h h'
end else
if xi < from_
then begin
assert (Seq.index xh i == Seq.index (Seq.slice bh 0 (U32.v from)) (xi - boff));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' 0 (U32.v from)) (xi - boff))
end else begin
assert (to_ <= xi);
assert (Seq.index xh i == Seq.index (Seq.slice bh (U32.v to) (length b)) (xi - to_));
assert (Seq.index xh' i == Seq.index (Seq.slice bh' (U32.v to) (length b)) (xi - to_))
end
in
Classical.forall_intro (Classical.move_requires prf);
assert (xh `Seq.equal` xh')
)
)
#pop-options
let modifies_loc_buffer_from_to_intro #a #rrel #rel b from to l h h' =
if g_is_null b
then ()
else modifies_loc_buffer_from_to_intro' b from to l h h'
let does_not_contain_addr = MG.does_not_contain_addr
let not_live_region_does_not_contain_addr = MG.not_live_region_does_not_contain_addr
let unused_in_does_not_contain_addr = MG.unused_in_does_not_contain_addr
let addr_unused_in_does_not_contain_addr = MG.addr_unused_in_does_not_contain_addr
let free_does_not_contain_addr = MG.free_does_not_contain_addr
let does_not_contain_addr_elim = MG.does_not_contain_addr_elim
let modifies_only_live_addresses = MG.modifies_only_live_addresses
let loc_not_unused_in = MG.loc_not_unused_in _
let loc_unused_in = MG.loc_unused_in _
let loc_regions_unused_in = MG.loc_regions_unused_in cls
let loc_unused_in_not_unused_in_disjoint =
MG.loc_unused_in_not_unused_in_disjoint cls
let not_live_region_loc_not_unused_in_disjoint = MG.not_live_region_loc_not_unused_in_disjoint cls
let live_loc_not_unused_in #_ #_ #_ b h =
unused_in_equiv b h;
Classical.move_requires (MG.does_not_contain_addr_addr_unused_in h) (frameOf b, as_addr b);
MG.loc_addresses_not_unused_in cls (frameOf b) (Set.singleton (as_addr b)) h;
()
let unused_in_loc_unused_in #_ #_ #_ b h =
unused_in_equiv b h;
Classical.move_requires (MG.addr_unused_in_does_not_contain_addr h) (frameOf b, as_addr b);
MG.loc_addresses_unused_in cls (frameOf b) (Set.singleton (as_addr b)) h;
() | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "LowStar.Monotonic.Buffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h: FStar.Monotonic.HyperStack.mem -> h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.modifies LowStar.Monotonic.Buffer.address_liveness_insensitive_locs
h
h')
(ensures
LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_not_unused_in h')
(LowStar.Monotonic.Buffer.loc_not_unused_in h) /\
LowStar.Monotonic.Buffer.loc_includes (LowStar.Monotonic.Buffer.loc_unused_in h)
(LowStar.Monotonic.Buffer.loc_unused_in h')) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_address_liveness_insensitive_unused_in",
"LowStar.Monotonic.Buffer.ubuffer",
"LowStar.Monotonic.Buffer.cls"
] | [] | true | false | true | false | false | let modifies_address_liveness_insensitive_unused_in =
| MG.modifies_address_liveness_insensitive_unused_in cls | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.