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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Hacl.Bignum.MontArithmetic.fsti | Hacl.Bignum.MontArithmetic.bn_field_one_st | val bn_field_one_st : t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | let bn_field_one_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> oneM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
live h oneM /\
B.(loc_disjoint (footprint h k) (loc_buffer (oneM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc oneM) h0 h1 /\
bn_v h1 oneM < bn_v_n h0 k /\
as_seq h1 oneM == S.bn_field_one (as_pctx h0 k)) | {
"file_name": "code/bignum/Hacl.Bignum.MontArithmetic.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 341,
"start_col": 0,
"start_line": 329
} | module Hacl.Bignum.MontArithmetic
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module B = LowStar.Buffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module Euclid = FStar.Math.Euclid
module S = Hacl.Spec.Bignum.MontArithmetic
module BE = Hacl.Bignum.Exponentiation
module BN = Hacl.Bignum
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val _align_fsti : unit
inline_for_extraction noextract
let lb (t:limb_t) =
match t with
| U32 -> buffer uint32
| U64 -> buffer uint64
inline_for_extraction noextract
let ll (t:limb_t) =
match t with
| U32 -> uint32
| U64 -> uint64
inline_for_extraction
noeq
type bn_mont_ctx' (t:limb_t) (a:Type0{a == lb t}) (b:Type0{b == ll t}) = {
len: BN.meta_len t;
n: x:a{length #MUT #(limb t) x == v len};
mu: b;
r2: x:a{length #MUT #(limb t) x == v len};
}
inline_for_extraction noextract
let bn_mont_ctx (t:limb_t) = bn_mont_ctx' t (lb t) (ll t)
let bn_mont_ctx_u32 = bn_mont_ctx' U32 (lb U32) (ll U32)
let bn_mont_ctx_u64 = bn_mont_ctx' U64 (lb U64) (ll U64)
inline_for_extraction noextract
let pbn_mont_ctx (t:limb_t) = B.pointer (bn_mont_ctx t)
inline_for_extraction noextract
let pbn_mont_ctx_u32 = B.pointer bn_mont_ctx_u32
inline_for_extraction noextract
let pbn_mont_ctx_u64 = B.pointer bn_mont_ctx_u64
inline_for_extraction noextract
let as_ctx (#t:limb_t) (h:mem) (k:bn_mont_ctx t) : GTot (S.bn_mont_ctx t) = {
S.len = v k.len;
S.n = as_seq h (k.n <: lbignum t k.len);
S.mu = k.mu;
S.r2 = as_seq h (k.r2 <: lbignum t k.len);
}
inline_for_extraction noextract
let bn_mont_ctx_inv (#t:limb_t) (h:mem) (k:bn_mont_ctx t) =
let n : buffer (limb t) = k.n in
let r2 : buffer (limb t) = k.r2 in
live h n /\ live h r2 /\ disjoint n r2 /\
S.bn_mont_ctx_inv (as_ctx h k)
inline_for_extraction noextract
let bn_v_n (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) =
let k1 = B.deref h k in
let n : lbignum t k1.len = k1.n in
bn_v h n
inline_for_extraction noextract
let freeable_s (#t:limb_t) (h:mem) (k:bn_mont_ctx t) =
let n : buffer (limb t) = k.n in
let r2 : buffer (limb t) = k.r2 in
B.freeable n /\ B.freeable r2
inline_for_extraction noextract
let freeable (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) =
B.freeable k /\ freeable_s h (B.deref h k)
inline_for_extraction noextract
let footprint_s (#t:limb_t) (h:mem) (k:bn_mont_ctx t) =
let n : buffer (limb t) = k.n in
let r2 : buffer (limb t) = k.r2 in
B.(loc_union (loc_addr_of_buffer n) (loc_addr_of_buffer r2))
inline_for_extraction noextract
let footprint (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) =
B.(loc_union (loc_addr_of_buffer k) (footprint_s h (B.deref h k)))
inline_for_extraction noextract
let as_pctx (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) : GTot (S.bn_mont_ctx t) =
as_ctx h (B.deref h k)
inline_for_extraction noextract
let pbn_mont_ctx_inv (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) =
B.live h k /\
B.(loc_disjoint (loc_addr_of_buffer k) (footprint_s h (B.deref h k))) /\
bn_mont_ctx_inv h (B.deref h k)
inline_for_extraction noextract
let bn_field_get_len_st (t:limb_t) = k:pbn_mont_ctx t ->
Stack (BN.meta_len t)
(requires fun h -> pbn_mont_ctx_inv h k)
(ensures fun h0 r h1 -> h0 == h1 /\
r == (B.deref h0 k).len /\
v r == S.bn_field_get_len (as_pctx h0 k))
inline_for_extraction noextract
val bn_field_get_len: #t:limb_t -> bn_field_get_len_st t
inline_for_extraction noextract
let bn_field_check_modulus_st (t:limb_t) (len:BN.meta_len t) = n:lbignum t len ->
Stack bool
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == S.bn_field_check_modulus (as_seq h0 n))
inline_for_extraction noextract
val bn_field_check_modulus: #t:limb_t -> km:BM.mont t -> bn_field_check_modulus_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_init_st (t:limb_t) (len:BN.meta_len t) =
r:HS.rid
-> n:lbignum t len ->
ST (pbn_mont_ctx t)
(requires fun h ->
S.bn_mont_ctx_pre (as_seq h n) /\
live h n /\ ST.is_eternal_region r)
(ensures fun h0 res h1 ->
B.(modifies loc_none h0 h1) /\
B.(fresh_loc (footprint h1 res) h0 h1) /\
B.(loc_includes (loc_region_only true r) (footprint h1 res)) /\
freeable h1 res /\
(B.deref h1 res).len == len /\ bn_v_n h1 res == bn_v h0 n /\
S.bn_mont_ctx_inv (as_pctx h1 res) /\
as_pctx h1 res == S.bn_field_init (as_seq h0 n))
inline_for_extraction noextract
val bn_field_init:
#t:limb_t
-> len:BN.meta_len t
-> precomp_r2:BM.bn_precomp_r2_mod_n_st t len ->
bn_field_init_st t len
inline_for_extraction noextract
let bn_field_free_st (t:limb_t) = k:pbn_mont_ctx t ->
ST unit
(requires fun h ->
freeable h k /\
pbn_mont_ctx_inv h k)
(ensures fun h0 _ h1 ->
B.(modifies (footprint h0 k) h0 h1))
inline_for_extraction noextract
val bn_field_free: #t:limb_t -> bn_field_free_st t
inline_for_extraction noextract
let bn_to_field_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> a:lbignum t len
-> aM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
live h a /\ live h aM /\ disjoint a aM /\
B.(loc_disjoint (footprint h k) (loc_buffer (a <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc aM) h0 h1 /\
bn_v h1 aM < bn_v_n h0 k /\
as_seq h1 aM == S.bn_to_field (as_pctx h0 k) (as_seq h0 a))
inline_for_extraction noextract
val bn_to_field: #t:limb_t -> km:BM.mont t -> bn_to_field_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_from_field_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> a:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\ bn_v h aM < bn_v_n h k /\
live h a /\ live h aM /\ disjoint a aM /\
B.(loc_disjoint (footprint h k) (loc_buffer (a <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc a) h0 h1 /\
bn_v h1 a < bn_v_n h0 k /\
as_seq h1 a == S.bn_from_field (as_pctx h0 k) (as_seq h0 aM))
inline_for_extraction noextract
val bn_from_field: #t:limb_t -> km:BM.mont t -> bn_from_field_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_add_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> bM:lbignum t len
-> cM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
bn_v h bM < bn_v_n h k /\
live h aM /\ live h bM /\ live h cM /\
eq_or_disjoint aM bM /\ eq_or_disjoint aM cM /\ eq_or_disjoint bM cM /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (bM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (cM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc cM) h0 h1 /\
bn_v h1 cM < bn_v_n h0 k /\
as_seq h1 cM == S.bn_field_add (as_pctx h0 k) (as_seq h0 aM) (as_seq h0 bM))
inline_for_extraction noextract
val bn_field_add: #t:limb_t -> km:BM.mont t -> bn_field_add_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_sub_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> bM:lbignum t len
-> cM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
bn_v h bM < bn_v_n h k /\
live h aM /\ live h bM /\ live h cM /\
eq_or_disjoint aM bM /\ eq_or_disjoint aM cM /\ eq_or_disjoint bM cM /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (bM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (cM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc cM) h0 h1 /\
bn_v h1 cM < bn_v_n h0 k /\
as_seq h1 cM == S.bn_field_sub (as_pctx h0 k) (as_seq h0 aM) (as_seq h0 bM))
inline_for_extraction noextract
val bn_field_sub: #t:limb_t -> km:BM.mont t -> bn_field_sub_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_mul_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> bM:lbignum t len
-> cM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
bn_v h bM < bn_v_n h k /\
live h aM /\ live h bM /\ live h cM /\
eq_or_disjoint aM bM /\ eq_or_disjoint aM cM /\ eq_or_disjoint bM cM /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (bM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (cM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc cM) h0 h1 /\
bn_v h1 cM < bn_v_n h0 k /\
as_seq h1 cM == S.bn_field_mul (as_pctx h0 k) (as_seq h0 aM) (as_seq h0 bM))
inline_for_extraction noextract
val bn_field_mul: #t:limb_t -> km:BM.mont t -> bn_field_mul_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_sqr_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> cM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
live h aM /\ live h cM /\ eq_or_disjoint aM cM /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (cM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc cM) h0 h1 /\
bn_v h1 cM < bn_v_n h0 k /\
as_seq h1 cM == S.bn_field_sqr (as_pctx h0 k) (as_seq h0 aM))
inline_for_extraction noextract
val bn_field_sqr: #t:limb_t -> km:BM.mont t -> bn_field_sqr_st t km.BM.bn.BN.len | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Euclid.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.MontArithmetic.fsti"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontArithmetic",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Euclid",
"short_module": "Euclid"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.meta_len",
"Hacl.Bignum.MontArithmetic.pbn_mont_ctx",
"Hacl.Bignum.Definitions.lbignum",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.eq2",
"Hacl.Bignum.MontArithmetic.__proj__Mkbn_mont_ctx'__item__len",
"Hacl.Bignum.MontArithmetic.lb",
"Hacl.Bignum.MontArithmetic.ll",
"LowStar.Monotonic.Buffer.deref",
"Hacl.Bignum.MontArithmetic.bn_mont_ctx",
"LowStar.Buffer.trivial_preorder",
"Hacl.Bignum.MontArithmetic.pbn_mont_ctx_inv",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Bignum.Definitions.limb",
"LowStar.Monotonic.Buffer.loc_disjoint",
"Hacl.Bignum.MontArithmetic.footprint",
"LowStar.Monotonic.Buffer.loc_buffer",
"LowStar.Buffer.buffer",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Bignum.Definitions.bn_v",
"Hacl.Bignum.MontArithmetic.bn_v_n",
"Lib.Sequence.seq",
"Prims.l_or",
"Prims.nat",
"FStar.Seq.Base.length",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.MontArithmetic.__proj__Mkbn_mont_ctx__item__len",
"Hacl.Bignum.MontArithmetic.as_pctx",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.MontArithmetic.__proj__Mkbn_mont_ctx__item__n",
"Lib.Buffer.as_seq",
"Hacl.Spec.Bignum.MontArithmetic.bn_field_one"
] | [] | false | false | false | false | true | let bn_field_one_st (t: limb_t) (len: BN.meta_len t) =
| k: pbn_mont_ctx t -> oneM: lbignum t len
-> Stack unit
(requires
fun h ->
(B.deref h k).len == len /\ pbn_mont_ctx_inv h k /\ live h oneM /\
B.(loc_disjoint (footprint h k) (loc_buffer (oneM <: buffer (limb t)))))
(ensures
fun h0 _ h1 ->
modifies (loc oneM) h0 h1 /\ bn_v h1 oneM < bn_v_n h0 k /\
as_seq h1 oneM == S.bn_field_one (as_pctx h0 k)) | false |
|
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.lemma_fits_c_lt_rn | val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n) | val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n) | let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 482,
"start_col": 0,
"start_line": 478
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | c: Prims.nat -> r: Prims.pos -> n: Prims.pos
-> FStar.Pervasives.Lemma (requires c < r * n) (ensures (c - n) / r < n) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.pos",
"FStar.Math.Lemmas.lemma_div_le",
"Prims.op_Subtraction",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Division",
"FStar.Math.Lemmas.cancel_mul_div",
"FStar.Mul.op_Star"
] | [] | true | false | true | false | false | let lemma_fits_c_lt_rn c r n =
| assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.lemma_mod_mul_distr3 | val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma
(a * (b % n) * c % n == a * b * c % n) | val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma
(a * (b % n) * c % n == a * b * c % n) | let lemma_mod_mul_distr3 a b c n =
calc (==) {
a * (b % n) * c % n;
(==) { }
(b % n) * a * c % n;
(==) { Math.Lemmas.paren_mul_right (b % n) a c }
(b % n) * (a * c) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l b (a * c) n }
b * (a * c) % n;
(==) { Math.Lemmas.paren_mul_right b a c }
a * b * c % n;
} | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 539,
"start_col": 0,
"start_line": 528
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n))
let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n
val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n))
let mont_mul_lemma pbits rLen n mu a b =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b)
/// Lemma (to_mont rLen n mu a == a * r % n)
val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Prims.int -> b: Prims.int -> c: Prims.int -> n: Prims.pos
-> FStar.Pervasives.Lemma (ensures (a * (b % n)) * c % n == (a * b) * c % n) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.int",
"Prims.pos",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.paren_mul_right",
"FStar.Math.Lemmas.lemma_mod_mul_distr_l"
] | [] | false | false | true | false | false | let lemma_mod_mul_distr3 a b c n =
| calc ( == ) {
(a * (b % n)) * c % n;
( == ) { () }
((b % n) * a) * c % n;
( == ) { Math.Lemmas.paren_mul_right (b % n) a c }
(b % n) * (a * c) % n;
( == ) { Math.Lemmas.lemma_mod_mul_distr_l b (a * c) n }
b * (a * c) % n;
( == ) { Math.Lemmas.paren_mul_right b a c }
(a * b) * c % n;
} | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.mont_reduction_loop_div_r_fits_lemma | val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n)) | val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n)) | let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n) | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 420,
"start_col": 0,
"start_line": 405
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | pbits: Prims.pos -> rLen: Prims.nat -> n: Prims.pos -> mu: Prims.nat -> c: Prims.nat
-> FStar.Pervasives.Lemma
(requires
(let r = Prims.pow2 (pbits * rLen) in
(1 + n * mu) % Prims.pow2 pbits == 0))
(ensures
(let res = Hacl.Spec.Montgomery.Lemmas.mont_reduction_loop_div_r pbits rLen n mu c in
let r = Prims.pow2 (pbits * rLen) in
res <= (c - n) / r + n)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Prims.op_Addition",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"FStar.Mul.op_Star",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.distributivity_sub_left",
"Prims.squash",
"FStar.Math.Lemmas.division_addition_lemma",
"FStar.Math.Lemmas.lemma_div_le",
"Prims.l_and",
"Prims.op_Modulus",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_loop_lemma",
"Lib.LoopCombinators.repeati",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_f",
"Prims.pow2"
] | [] | false | false | true | false | false | let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
| let r = pow2 (pbits * rLen) in
let res:nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc ( == ) {
(c + (r - 1) * n) / r;
( == ) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
( == ) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n) | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.mont_reduction_lemma_step | val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n)) | val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n)) | let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0 | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 57,
"end_line": 379,
"start_col": 0,
"start_line": 376
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
pbits: Prims.pos ->
rLen: Prims.nat ->
n: Prims.pos ->
mu: Prims.nat ->
i: Prims.pos{i <= rLen} ->
c: Prims.nat ->
res0: Prims.nat
-> FStar.Pervasives.Lemma
(requires
res0 % n == c % n /\ res0 % Prims.pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (Prims.pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % Prims.pow2 pbits == 0)
(ensures
(let res = Hacl.Spec.Montgomery.Lemmas.mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % Prims.pow2 (pbits * i) == 0 /\
res <= c + (Prims.pow2 (pbits * i) - 1) * n)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_lemma_step_modn",
"Prims.unit",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_lemma_step_modr",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_lemma_step_bound"
] | [] | true | false | true | false | false | let mont_reduction_lemma_step pbits rLen n mu i c res0 =
| mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0 | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.mont_reduction_lemma_step_modr_aux | val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1) | val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1) | let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
} | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 335,
"start_col": 0,
"start_line": 322
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | pbits: Prims.pos -> n: Prims.pos -> q_i: Prims.nat -> i: Prims.pos -> res0: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
(let b1 = Prims.pow2 (pbits * (i - 1)) in
((res0 / b1) * b1 + (n * q_i) * b1) % Prims.pow2 (pbits * i) ==
((res0 / b1 % Prims.pow2 pbits + n * q_i) % Prims.pow2 pbits) * b1)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.op_Division",
"Prims.pow2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.distributivity_add_left",
"Prims.squash",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2",
"Prims.op_Subtraction",
"FStar.Math.Lemmas.lemma_mod_plus_distr_l",
"Prims._assert",
"FStar.Math.Lemmas.distributivity_sub_right"
] | [] | false | false | true | false | false | let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
| let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc ( == ) {
((res0 / b1) * b1 + (n * q_i) * b1) % pow2 (pbits * i);
( == ) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
( == ) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i)
(pbits * i)
(pbits * (i - 1)) }
((res0 / b1 + n * q_i) % pow2 pbits) * b1;
( == ) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
((res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits) * b1;
} | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.mont_reduction_lemma_step_mod_pbits | val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0) | val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0) | let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
} | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 315,
"start_col": 0,
"start_line": 294
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | pbits: Prims.pos -> n: Prims.pos -> mu: Prims.nat -> c_i: Prims.nat
-> FStar.Pervasives.Lemma (requires (1 + n * mu) % Prims.pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % Prims.pow2 pbits)) % Prims.pow2 pbits == 0) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.lemma_mod_plus_distr_r",
"Prims.squash",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"FStar.Math.Lemmas.paren_mul_right",
"FStar.Math.Lemmas.distributivity_add_left",
"FStar.Math.Lemmas.lemma_mod_mul_distr_l",
"Prims._assert",
"Prims.b2t",
"Prims.op_Equality",
"Prims.pow2"
] | [] | false | false | true | false | false | let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
| let r = pow2 pbits in
let q_i = mu * c_i % r in
calc ( == ) {
(c_i + n * q_i) % r;
( == ) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
( == ) { () }
(c_i + n * (mu * c_i % r) % r) % r;
( == ) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
( == ) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
( == ) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + (n * mu) * c_i) % r;
( == ) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
( == ) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
(((1 + n * mu) % r) * c_i) % r;
( == ) { assert ((1 + n * mu) % r = 0) }
0;
} | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.mont_reduction_loop_div_r_lemma | val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n)) | val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n)) | let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 58,
"end_line": 469,
"start_col": 0,
"start_line": 465
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | pbits: Prims.pos -> rLen: Prims.pos -> n: Prims.pos -> mu: Prims.nat -> c: Prims.nat
-> FStar.Pervasives.Lemma (requires Hacl.Spec.Montgomery.Lemmas.mont_pre pbits rLen n mu)
(ensures
(let res = Hacl.Spec.Montgomery.Lemmas.mont_reduction_loop_div_r pbits rLen n mu c in
let r = Prims.pow2 (pbits * rLen) in
let _ = Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd (pbits * rLen) n in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ d _ = _ in
res % n == c * d % n /\ res <= (c - n) / r + n)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.int",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_loop_div_r_eval_lemma",
"Prims.unit",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_loop_div_r_fits_lemma",
"Hacl.Spec.Montgomery.Lemmas.mont_preconditions_d",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd",
"FStar.Mul.op_Star"
] | [] | false | false | true | false | false | let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
| let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c | false |
Vale.AES.GCTR.fsti | Vale.AES.GCTR.make_gctr_plain_LE | val make_gctr_plain_LE (p: seq nat8) : seq nat8 | val make_gctr_plain_LE (p: seq nat8) : seq nat8 | let make_gctr_plain_LE (p:seq nat8) : seq nat8 =
if length p < pow2_32 then p else empty | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 17,
"start_col": 0,
"start_line": 16
} | module Vale.AES.GCTR
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.GCTR_s.fst.checked",
"Vale.AES.GCM_helpers.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: FStar.Seq.Base.seq Vale.Def.Types_s.nat8 -> FStar.Seq.Base.seq Vale.Def.Types_s.nat8 | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Vale.Def.Words_s.pow2_32",
"Prims.bool",
"FStar.Seq.Base.empty"
] | [] | false | false | false | true | false | let make_gctr_plain_LE (p: seq nat8) : seq nat8 =
| if length p < pow2_32 then p else empty | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.mont_reduction_lemma | val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n)) | val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n)) | let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 506,
"start_col": 0,
"start_line": 491
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | pbits: Prims.pos -> rLen: Prims.pos -> n: Prims.pos -> mu: Prims.nat -> c: Prims.nat
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.Montgomery.Lemmas.mont_pre pbits rLen n mu /\ c < Prims.pow2 (pbits * rLen) * n)
(ensures
(let _ = Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd (pbits * rLen) n in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ d _ = _ in
Hacl.Spec.Montgomery.Lemmas.mont_reduction pbits rLen n mu c == c * d % n)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.int",
"FStar.Math.Lemmas.small_mod",
"Prims.unit",
"Prims.op_LessThan",
"Prims.bool",
"Hacl.Spec.Montgomery.Lemmas.lemma_fits_c_lt_rn",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.eq2",
"Prims.op_Modulus",
"FStar.Math.Lemmas.lemma_mod_sub",
"Prims.op_GreaterThanOrEqual",
"Prims.l_and",
"FStar.Mul.op_Star",
"Prims.op_Addition",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_loop_div_r_lemma",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_loop_div_r",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd",
"Prims.pow2"
] | [] | false | false | true | false | false | let mont_reduction_lemma pbits rLen n mu c =
| let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n
then ()
else
(assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n);
Math.Lemmas.small_mod res1 n | false |
Vale.AES.GCTR.fsti | Vale.AES.GCTR.empty_seq_quad32 | val empty_seq_quad32:seq quad32 | val empty_seq_quad32:seq quad32 | let empty_seq_quad32 : seq quad32 = empty | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 27,
"start_col": 0,
"start_line": 27
} | module Vale.AES.GCTR
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
let make_gctr_plain_LE (p:seq nat8) : seq nat8 =
if length p < pow2_32 then p else empty
let inc32lite (cb:quad32) (i:int) : quad32 =
if 0 <= i && i < pow2_32 then
let sum = cb.lo0 + i in
let lo0 = if sum >= pow2_32 then sum - pow2_32 else sum in
Mkfour lo0 cb.lo1 cb.hi2 cb.hi3
else
Mkfour 42 42 42 42 | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.GCTR_s.fst.checked",
"Vale.AES.GCM_helpers.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.Seq.Base.seq Vale.Def.Types_s.quad32 | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.empty",
"Vale.Def.Types_s.quad32"
] | [] | false | false | false | true | false | let empty_seq_quad32:seq quad32 =
| empty | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.mont_mul_lemma | val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n)) | val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n)) | let mont_mul_lemma pbits rLen n mu a b =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b) | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 46,
"end_line": 522,
"start_col": 0,
"start_line": 514
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n))
let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n
val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | pbits: Prims.pos -> rLen: Prims.pos -> n: Prims.pos -> mu: Prims.nat -> a: Prims.nat -> b: Prims.nat
-> FStar.Pervasives.Lemma
(requires Hacl.Spec.Montgomery.Lemmas.mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures
(let _ = Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd (pbits * rLen) n in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ d _ = _ in
Hacl.Spec.Montgomery.Lemmas.mont_mul pbits rLen n mu a b == (a * b) * d % n)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.int",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_lemma",
"FStar.Mul.op_Star",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Math.Lemmas.lemma_mult_lt_right",
"FStar.Math.Lemmas.lemma_mult_lt_sqr",
"Hacl.Spec.Montgomery.Lemmas.mont_mul",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd",
"Prims.pow2"
] | [] | false | false | true | false | false | let mont_mul_lemma pbits rLen n mu a b =
| let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b) | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.lemma_mont_mul_one | val lemma_mont_mul_one: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (let r0 = 1 * r % n in let r1 = a * r % n in r0 * r1 * d % n == r1 % n) | val lemma_mont_mul_one: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (let r0 = 1 * r % n in let r1 = a * r % n in r0 * r1 * d % n == r1 % n) | let lemma_mont_mul_one n r d a =
let r0 = 1 * r % n in
let r1 = a * r % n in
calc (==) {
r1 * r0 * d % n;
(==) { Math.Lemmas.paren_mul_right r1 r0 d; Math.Lemmas.lemma_mod_mul_distr_r r1 (r0 * d) n }
r1 * (r0 * d % n) % n;
(==) { lemma_mont_id n r d 1 }
r1 * (1 % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r r1 1 n }
r1 % n;
} | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 671,
"start_col": 0,
"start_line": 659
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n))
let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n
val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n))
let mont_mul_lemma pbits rLen n mu a b =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b)
/// Lemma (to_mont rLen n mu a == a * r % n)
val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma
(a * (b % n) * c % n == a * b * c % n)
let lemma_mod_mul_distr3 a b c n =
calc (==) {
a * (b % n) * c % n;
(==) { }
(b % n) * a * c % n;
(==) { Math.Lemmas.paren_mul_right (b % n) a c }
(b % n) * (a * c) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l b (a * c) n }
b * (a * c) % n;
(==) { Math.Lemmas.paren_mul_right b a c }
a * b * c % n;
}
val mult_lt_lemma: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d)
let mult_lt_lemma a b c d = ()
val to_mont_eval_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
a * r2 * d % n == a * r % n))
let to_mont_eval_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let c = a * r2 in
calc (==) {
c * d % n;
(==) { }
a * r2 * d % n;
(==) { Math.Lemmas.paren_mul_right 2 pbits rLen;
Math.Lemmas.pow2_plus (pbits * rLen) (pbits * rLen) }
a * (r * r % n) * d % n;
(==) { lemma_mod_mul_distr3 a (r * r) d n }
a * (r * r) * d % n;
(==) { Math.Lemmas.paren_mul_right a r r }
a * r * r * d % n;
(==) { Math.Lemmas.paren_mul_right (a * r) r d }
a * r * (r * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (a * r) (r * d) n }
a * r * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a * r % n;
};
assert (c * d % n == a * r % n)
val to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < pow2 (pbits * rLen))
(ensures to_mont pbits rLen n mu a == a * pow2 (pbits * rLen) % n)
let to_mont_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let c = a * r2 in
let aM = to_mont pbits rLen n mu a in
assert (aM == mont_reduction pbits rLen n mu c);
mult_lt_lemma a r2 r n;
assert (a * r2 < r * n);
mont_reduction_lemma pbits rLen n mu c;
assert (aM == c * d % n);
to_mont_eval_lemma pbits rLen n mu a;
assert (aM == a * r % n)
/// Lemma (from_mont rLen n mu aM == aM * d % n)
val from_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ aM < pow2 (pbits * rLen))
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
from_mont pbits rLen n mu aM == aM * d % n))
let from_mont_lemma pbits rLen n mu aM =
mont_reduction_lemma pbits rLen n mu aM
/// Lemma (mont_one pbits rLen n mu == 1 * r % n)
val mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures mont_one pbits rLen n mu == 1 * pow2 (pbits * rLen) % n)
let mont_one_lemma pbits rLen n mu =
to_mont_lemma pbits rLen n mu 1
/// Properties of Montgomery arithmetic
// from_mont (to_mont a) = a % n
val lemma_mont_id: n:pos -> r:pos -> d:int{r * d % n == 1} -> a:nat ->
Lemma (a * r % n * d % n == a % n)
let lemma_mont_id n r d a =
calc (==) {
a * r % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * r) d n }
a * r * d % n;
(==) { Math.Lemmas.paren_mul_right a r d; Math.Lemmas.lemma_mod_mul_distr_r a (r * d) n }
a * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a % n;
}
// to_mont (mont_reduction a) = a % n
val lemma_mont_id1: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (a * d % n * r % n == a % n)
let lemma_mont_id1 n r d a =
calc (==) {
((a * d % n) * r) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * d) r n }
((a * d) * r) % n;
(==) { Math.Lemmas.paren_mul_right a d r }
(a * (d * r)) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r a (d * r) n }
(a * (d * r % n)) % n;
(==) { assert (r * d % n = 1) }
a % n;
};
assert (a * d % n * r % n == a % n)
// one_M * a = a
val lemma_mont_mul_one: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.pos -> r: Prims.pos -> d: Prims.int{r * d % n = 1} -> a: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
(let r0 = 1 * r % n in
let r1 = a * r % n in
(r0 * r1) * d % n == r1 % n)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.int",
"Prims.b2t",
"Prims.op_Equality",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"FStar.Math.Lemmas.paren_mul_right",
"Prims.squash",
"Hacl.Spec.Montgomery.Lemmas.lemma_mont_id"
] | [] | false | false | true | false | false | let lemma_mont_mul_one n r d a =
| let r0 = 1 * r % n in
let r1 = a * r % n in
calc ( == ) {
(r1 * r0) * d % n;
( == ) { (Math.Lemmas.paren_mul_right r1 r0 d;
Math.Lemmas.lemma_mod_mul_distr_r r1 (r0 * d) n) }
r1 * (r0 * d % n) % n;
( == ) { lemma_mont_id n r d 1 }
r1 * (1 % n) % n;
( == ) { Math.Lemmas.lemma_mod_mul_distr_r r1 1 n }
r1 % n;
} | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.lemma_mont_id | val lemma_mont_id: n:pos -> r:pos -> d:int{r * d % n == 1} -> a:nat ->
Lemma (a * r % n * d % n == a % n) | val lemma_mont_id: n:pos -> r:pos -> d:int{r * d % n == 1} -> a:nat ->
Lemma (a * r % n * d % n == a % n) | let lemma_mont_id n r d a =
calc (==) {
a * r % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * r) d n }
a * r * d % n;
(==) { Math.Lemmas.paren_mul_right a r d; Math.Lemmas.lemma_mod_mul_distr_r a (r * d) n }
a * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a % n;
} | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 635,
"start_col": 0,
"start_line": 626
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n))
let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n
val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n))
let mont_mul_lemma pbits rLen n mu a b =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b)
/// Lemma (to_mont rLen n mu a == a * r % n)
val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma
(a * (b % n) * c % n == a * b * c % n)
let lemma_mod_mul_distr3 a b c n =
calc (==) {
a * (b % n) * c % n;
(==) { }
(b % n) * a * c % n;
(==) { Math.Lemmas.paren_mul_right (b % n) a c }
(b % n) * (a * c) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l b (a * c) n }
b * (a * c) % n;
(==) { Math.Lemmas.paren_mul_right b a c }
a * b * c % n;
}
val mult_lt_lemma: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d)
let mult_lt_lemma a b c d = ()
val to_mont_eval_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
a * r2 * d % n == a * r % n))
let to_mont_eval_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let c = a * r2 in
calc (==) {
c * d % n;
(==) { }
a * r2 * d % n;
(==) { Math.Lemmas.paren_mul_right 2 pbits rLen;
Math.Lemmas.pow2_plus (pbits * rLen) (pbits * rLen) }
a * (r * r % n) * d % n;
(==) { lemma_mod_mul_distr3 a (r * r) d n }
a * (r * r) * d % n;
(==) { Math.Lemmas.paren_mul_right a r r }
a * r * r * d % n;
(==) { Math.Lemmas.paren_mul_right (a * r) r d }
a * r * (r * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (a * r) (r * d) n }
a * r * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a * r % n;
};
assert (c * d % n == a * r % n)
val to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < pow2 (pbits * rLen))
(ensures to_mont pbits rLen n mu a == a * pow2 (pbits * rLen) % n)
let to_mont_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let c = a * r2 in
let aM = to_mont pbits rLen n mu a in
assert (aM == mont_reduction pbits rLen n mu c);
mult_lt_lemma a r2 r n;
assert (a * r2 < r * n);
mont_reduction_lemma pbits rLen n mu c;
assert (aM == c * d % n);
to_mont_eval_lemma pbits rLen n mu a;
assert (aM == a * r % n)
/// Lemma (from_mont rLen n mu aM == aM * d % n)
val from_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ aM < pow2 (pbits * rLen))
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
from_mont pbits rLen n mu aM == aM * d % n))
let from_mont_lemma pbits rLen n mu aM =
mont_reduction_lemma pbits rLen n mu aM
/// Lemma (mont_one pbits rLen n mu == 1 * r % n)
val mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures mont_one pbits rLen n mu == 1 * pow2 (pbits * rLen) % n)
let mont_one_lemma pbits rLen n mu =
to_mont_lemma pbits rLen n mu 1
/// Properties of Montgomery arithmetic
// from_mont (to_mont a) = a % n
val lemma_mont_id: n:pos -> r:pos -> d:int{r * d % n == 1} -> a:nat -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.pos -> r: Prims.pos -> d: Prims.int{r * d % n == 1} -> a: Prims.nat
-> FStar.Pervasives.Lemma (ensures (a * r % n) * d % n == a % n) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.int",
"Prims.eq2",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.lemma_mod_mul_distr_l",
"Prims.squash",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"FStar.Math.Lemmas.paren_mul_right",
"Prims._assert"
] | [] | false | false | true | false | false | let lemma_mont_id n r d a =
| calc ( == ) {
(a * r % n) * d % n;
( == ) { Math.Lemmas.lemma_mod_mul_distr_l (a * r) d n }
(a * r) * d % n;
( == ) { (Math.Lemmas.paren_mul_right a r d;
Math.Lemmas.lemma_mod_mul_distr_r a (r * d) n) }
a * (r * d % n) % n;
( == ) { assert (r * d % n == 1) }
a % n;
} | false |
Spec.Poly1305.Test.fst | Spec.Poly1305.Test.test | val test : _: Prims.unit -> FStar.All.ALL Prims.bool | let test () =
let mac = poly1305_mac msg key in
let res = PS.print_compare true (length mac) expected mac in
if res then begin IO.print_string "\nPoly1305: Success!\n"; true end
else begin IO.print_string "\nPoly1305: Failure :(\n"; false end | {
"file_name": "specs/tests/Spec.Poly1305.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 55,
"start_col": 0,
"start_line": 50
} | module Spec.Poly1305.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Poly1305
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(* ********************* *)
(* RFC 7539 Test Vectors *)
(* ********************* *)
let msg : lbytes 34 =
let l = List.Tot.map u8_from_UInt8 [
0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy;
0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy;
0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy;
0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy;
0x75uy; 0x70uy
] in
assert_norm (List.Tot.length l == 34);
of_list l
let key : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy;
0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy;
0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy;
0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let expected : lbytes 16 =
let l = List.Tot.map u8_from_UInt8 [
0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy;
0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy
] in
assert_norm (List.Tot.length l == 16);
of_list l | {
"checked_file": "/",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.IO.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Poly1305.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Poly1305",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.All.ALL Prims.bool | FStar.All.ALL | [] | [] | [
"Prims.unit",
"Prims.bool",
"FStar.IO.print_string",
"Lib.PrintSequence.print_compare",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Poly1305.Test.expected",
"Spec.Poly1305.tag",
"Spec.Poly1305.poly1305_mac",
"Spec.Poly1305.Test.msg",
"Spec.Poly1305.Test.key"
] | [] | false | true | false | false | false | let test () =
| let mac = poly1305_mac msg key in
let res = PS.print_compare true (length mac) expected mac in
if res
then
(IO.print_string "\nPoly1305: Success!\n";
true)
else
(IO.print_string "\nPoly1305: Failure :(\n";
false) | false |
|
Vale.AES.GCTR.fsti | Vale.AES.GCTR.gctr_registers_reveal | val gctr_registers_reveal : _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures Vale.AES.GCTR.gctr_registers == Vale.AES.GCTR.gctr_registers_def) | let gctr_registers_reveal = opaque_revealer (`%gctr_registers) gctr_registers gctr_registers_def | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 108,
"end_line": 90,
"start_col": 12,
"start_line": 90
} | module Vale.AES.GCTR
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
let make_gctr_plain_LE (p:seq nat8) : seq nat8 =
if length p < pow2_32 then p else empty
let inc32lite (cb:quad32) (i:int) : quad32 =
if 0 <= i && i < pow2_32 then
let sum = cb.lo0 + i in
let lo0 = if sum >= pow2_32 then sum - pow2_32 else sum in
Mkfour lo0 cb.lo1 cb.hi2 cb.hi3
else
Mkfour 42 42 42 42
let empty_seq_quad32 : seq quad32 = empty
val lemma_counter_init (x:quad32) (low64 low8:nat64) : Lemma
(requires low64 == lo64 x /\
low8 == iand64 low64 0xff)
(ensures low8 == x.lo0 % 256)
let partial_seq_agreement (x y:seq quad32) (lo hi:nat) =
lo <= hi /\ hi <= length x /\ hi <= length y /\
(forall i . {:pattern (index x i) \/ (index y i)} lo <= i /\ i < hi ==> index x i == index y i)
(*
let lemma_partial_seq_agreement_subset (x y:seq quad32) (lo hi hi':nat) : Lemma
(requires lo <= hi /\ hi <= hi' /\ hi' <= length x /\ hi' <= length y /\
partial_seq_agreement x y lo hi')
(ensures partial_seq_agreement x y lo hi)
=
()
*)
(*
let lemma_partial_seq_agreement_step (x y z:seq quad32) (lo mid hi:nat) : Lemma
(requires partial_seq_agreement x y lo hi /\
length z >= hi /\
lo <= mid /\ mid < hi /\
(forall i . 0 <= i /\ i < length z /\ (i < lo || i > mid) ==>
index y i == index z i))
(ensures partial_seq_agreement x z (mid+1) hi)
=
()
*)
val gctr_encrypt_block_offset (icb_BE:quad32) (plain_LE:quad32) (alg:algorithm) (key:seq nat32) (i:int) : Lemma
(requires is_aes_key_LE alg key)
(ensures
gctr_encrypt_block icb_BE plain_LE alg key i ==
gctr_encrypt_block (inc32 icb_BE i) plain_LE alg key 0
)
val gctr_encrypt_empty (icb_BE:quad32) (plain_LE cipher_LE:seq quad32) (alg:algorithm) (key:seq nat32) : Lemma
(requires is_aes_key_LE alg key)
(ensures (
let plain = slice (le_seq_quad32_to_bytes plain_LE) 0 0 in
let cipher = slice (le_seq_quad32_to_bytes cipher_LE) 0 0 in
cipher = gctr_encrypt_LE icb_BE (make_gctr_plain_LE plain) alg key
))
let aes_encrypt_BE (alg:algorithm) (key:seq nat32) (p_BE:quad32) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let p_LE = reverse_bytes_quad32 p_BE in
aes_encrypt_LE alg key p_LE
let gctr_registers_def (r0 r1 r2 r3 r4 r5:quad32) (s:seq quad32) (alg:algorithm) (key:seq nat32) (ctr_BE:quad32) (i:int) : prop0 =
0 <= i /\ i*6 + 5 < length s /\
is_aes_key_LE alg key /\
r0 = quad32_xor (index s (i*6 + 0)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 0))) /\
r1 = quad32_xor (index s (i*6 + 1)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 1))) /\
r2 = quad32_xor (index s (i*6 + 2)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 2))) /\
r3 = quad32_xor (index s (i*6 + 3)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 3))) /\
r4 = quad32_xor (index s (i*6 + 4)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 4))) /\
r5 = quad32_xor (index s (i*6 + 5)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 5))) | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.GCTR_s.fst.checked",
"Vale.AES.GCM_helpers.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures Vale.AES.GCTR.gctr_registers == Vale.AES.GCTR.gctr_registers_def) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Opaque_s.opaque_revealer",
"Vale.Def.Types_s.quad32",
"FStar.Seq.Base.seq",
"Vale.AES.AES_common_s.algorithm",
"Vale.Def.Types_s.nat32",
"Prims.int",
"Vale.Def.Prop_s.prop0",
"Vale.AES.GCTR.gctr_registers",
"Vale.AES.GCTR.gctr_registers_def"
] | [] | true | false | true | false | false | let gctr_registers_reveal =
| opaque_revealer (`%gctr_registers) gctr_registers gctr_registers_def | false |
|
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.mont_reduction_loop_lemma | val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n)) | val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n)) | let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 58,
"end_line": 395,
"start_col": 0,
"start_line": 387
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
pbits: Prims.pos ->
rLen: Prims.nat ->
n: Prims.pos ->
mu: Prims.nat ->
i: Prims.nat{i <= rLen} ->
c: Prims.nat
-> FStar.Pervasives.Lemma (requires (1 + n * mu) % Prims.pow2 pbits == 0)
(ensures
(let res =
Lib.LoopCombinators.repeati i
(Hacl.Spec.Montgomery.Lemmas.mont_reduction_f pbits rLen n mu)
c
in
res % n == c % n /\ res % Prims.pow2 (pbits * i) == 0 /\
res <= c + (Prims.pow2 (pbits * i) - 1) * n)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Lib.LoopCombinators.eq_repeati0",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_f",
"Prims.bool",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_lemma_step",
"Prims.unit",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_loop_lemma",
"Prims.op_Subtraction",
"Lib.LoopCombinators.repeati",
"Lib.LoopCombinators.unfold_repeati"
] | [
"recursion"
] | false | false | true | false | false | let rec mont_reduction_loop_lemma pbits rLen n mu i c =
| let res:nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0
then eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else
(unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0:nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0) | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.mont_one_lemma | val mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures mont_one pbits rLen n mu == 1 * pow2 (pbits * rLen) % n) | val mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures mont_one pbits rLen n mu == 1 * pow2 (pbits * rLen) % n) | let mont_one_lemma pbits rLen n mu =
to_mont_lemma pbits rLen n mu 1 | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 33,
"end_line": 618,
"start_col": 0,
"start_line": 617
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n))
let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n
val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n))
let mont_mul_lemma pbits rLen n mu a b =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b)
/// Lemma (to_mont rLen n mu a == a * r % n)
val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma
(a * (b % n) * c % n == a * b * c % n)
let lemma_mod_mul_distr3 a b c n =
calc (==) {
a * (b % n) * c % n;
(==) { }
(b % n) * a * c % n;
(==) { Math.Lemmas.paren_mul_right (b % n) a c }
(b % n) * (a * c) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l b (a * c) n }
b * (a * c) % n;
(==) { Math.Lemmas.paren_mul_right b a c }
a * b * c % n;
}
val mult_lt_lemma: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d)
let mult_lt_lemma a b c d = ()
val to_mont_eval_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
a * r2 * d % n == a * r % n))
let to_mont_eval_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let c = a * r2 in
calc (==) {
c * d % n;
(==) { }
a * r2 * d % n;
(==) { Math.Lemmas.paren_mul_right 2 pbits rLen;
Math.Lemmas.pow2_plus (pbits * rLen) (pbits * rLen) }
a * (r * r % n) * d % n;
(==) { lemma_mod_mul_distr3 a (r * r) d n }
a * (r * r) * d % n;
(==) { Math.Lemmas.paren_mul_right a r r }
a * r * r * d % n;
(==) { Math.Lemmas.paren_mul_right (a * r) r d }
a * r * (r * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (a * r) (r * d) n }
a * r * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a * r % n;
};
assert (c * d % n == a * r % n)
val to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < pow2 (pbits * rLen))
(ensures to_mont pbits rLen n mu a == a * pow2 (pbits * rLen) % n)
let to_mont_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let c = a * r2 in
let aM = to_mont pbits rLen n mu a in
assert (aM == mont_reduction pbits rLen n mu c);
mult_lt_lemma a r2 r n;
assert (a * r2 < r * n);
mont_reduction_lemma pbits rLen n mu c;
assert (aM == c * d % n);
to_mont_eval_lemma pbits rLen n mu a;
assert (aM == a * r % n)
/// Lemma (from_mont rLen n mu aM == aM * d % n)
val from_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ aM < pow2 (pbits * rLen))
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
from_mont pbits rLen n mu aM == aM * d % n))
let from_mont_lemma pbits rLen n mu aM =
mont_reduction_lemma pbits rLen n mu aM
/// Lemma (mont_one pbits rLen n mu == 1 * r % n)
val mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures mont_one pbits rLen n mu == 1 * pow2 (pbits * rLen) % n) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | pbits: Prims.pos -> rLen: Prims.pos -> n: Prims.pos -> mu: Prims.nat
-> FStar.Pervasives.Lemma (requires Hacl.Spec.Montgomery.Lemmas.mont_pre pbits rLen n mu)
(ensures
Hacl.Spec.Montgomery.Lemmas.mont_one pbits rLen n mu == 1 * Prims.pow2 (pbits * rLen) % n) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Hacl.Spec.Montgomery.Lemmas.to_mont_lemma",
"Prims.unit"
] | [] | true | false | true | false | false | let mont_one_lemma pbits rLen n mu =
| to_mont_lemma pbits rLen n mu 1 | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.from_mont_lemma | val from_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ aM < pow2 (pbits * rLen))
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
from_mont pbits rLen n mu aM == aM * d % n)) | val from_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ aM < pow2 (pbits * rLen))
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
from_mont pbits rLen n mu aM == aM * d % n)) | let from_mont_lemma pbits rLen n mu aM =
mont_reduction_lemma pbits rLen n mu aM | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 608,
"start_col": 0,
"start_line": 607
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n))
let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n
val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n))
let mont_mul_lemma pbits rLen n mu a b =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b)
/// Lemma (to_mont rLen n mu a == a * r % n)
val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma
(a * (b % n) * c % n == a * b * c % n)
let lemma_mod_mul_distr3 a b c n =
calc (==) {
a * (b % n) * c % n;
(==) { }
(b % n) * a * c % n;
(==) { Math.Lemmas.paren_mul_right (b % n) a c }
(b % n) * (a * c) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l b (a * c) n }
b * (a * c) % n;
(==) { Math.Lemmas.paren_mul_right b a c }
a * b * c % n;
}
val mult_lt_lemma: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d)
let mult_lt_lemma a b c d = ()
val to_mont_eval_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
a * r2 * d % n == a * r % n))
let to_mont_eval_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let c = a * r2 in
calc (==) {
c * d % n;
(==) { }
a * r2 * d % n;
(==) { Math.Lemmas.paren_mul_right 2 pbits rLen;
Math.Lemmas.pow2_plus (pbits * rLen) (pbits * rLen) }
a * (r * r % n) * d % n;
(==) { lemma_mod_mul_distr3 a (r * r) d n }
a * (r * r) * d % n;
(==) { Math.Lemmas.paren_mul_right a r r }
a * r * r * d % n;
(==) { Math.Lemmas.paren_mul_right (a * r) r d }
a * r * (r * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (a * r) (r * d) n }
a * r * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a * r % n;
};
assert (c * d % n == a * r % n)
val to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < pow2 (pbits * rLen))
(ensures to_mont pbits rLen n mu a == a * pow2 (pbits * rLen) % n)
let to_mont_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let c = a * r2 in
let aM = to_mont pbits rLen n mu a in
assert (aM == mont_reduction pbits rLen n mu c);
mult_lt_lemma a r2 r n;
assert (a * r2 < r * n);
mont_reduction_lemma pbits rLen n mu c;
assert (aM == c * d % n);
to_mont_eval_lemma pbits rLen n mu a;
assert (aM == a * r % n)
/// Lemma (from_mont rLen n mu aM == aM * d % n)
val from_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ aM < pow2 (pbits * rLen))
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
from_mont pbits rLen n mu aM == aM * d % n)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | pbits: Prims.pos -> rLen: Prims.pos -> n: Prims.pos -> mu: Prims.nat -> aM: Prims.nat
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.Montgomery.Lemmas.mont_pre pbits rLen n mu /\ aM < Prims.pow2 (pbits * rLen))
(ensures
(let _ = Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd (pbits * rLen) n in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ d _ = _ in
Hacl.Spec.Montgomery.Lemmas.from_mont pbits rLen n mu aM == aM * d % n)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_lemma",
"Prims.unit"
] | [] | true | false | true | false | false | let from_mont_lemma pbits rLen n mu aM =
| mont_reduction_lemma pbits rLen n mu aM | false |
Vale.AES.GCTR.fsti | Vale.AES.GCTR.gctr_registers | val gctr_registers : _: Vale.Def.Types_s.quad32 ->
_: Vale.Def.Types_s.quad32 ->
_: Vale.Def.Types_s.quad32 ->
_: Vale.Def.Types_s.quad32 ->
_: Vale.Def.Types_s.quad32 ->
_: Vale.Def.Types_s.quad32 ->
_: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
_: Vale.AES.AES_common_s.algorithm ->
_: FStar.Seq.Base.seq Vale.Def.Types_s.nat32 ->
_: Vale.Def.Types_s.quad32 ->
_: Prims.int
-> Vale.Def.Prop_s.prop0 | let gctr_registers = opaque_make gctr_registers_def | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 70,
"end_line": 89,
"start_col": 19,
"start_line": 89
} | module Vale.AES.GCTR
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
let make_gctr_plain_LE (p:seq nat8) : seq nat8 =
if length p < pow2_32 then p else empty
let inc32lite (cb:quad32) (i:int) : quad32 =
if 0 <= i && i < pow2_32 then
let sum = cb.lo0 + i in
let lo0 = if sum >= pow2_32 then sum - pow2_32 else sum in
Mkfour lo0 cb.lo1 cb.hi2 cb.hi3
else
Mkfour 42 42 42 42
let empty_seq_quad32 : seq quad32 = empty
val lemma_counter_init (x:quad32) (low64 low8:nat64) : Lemma
(requires low64 == lo64 x /\
low8 == iand64 low64 0xff)
(ensures low8 == x.lo0 % 256)
let partial_seq_agreement (x y:seq quad32) (lo hi:nat) =
lo <= hi /\ hi <= length x /\ hi <= length y /\
(forall i . {:pattern (index x i) \/ (index y i)} lo <= i /\ i < hi ==> index x i == index y i)
(*
let lemma_partial_seq_agreement_subset (x y:seq quad32) (lo hi hi':nat) : Lemma
(requires lo <= hi /\ hi <= hi' /\ hi' <= length x /\ hi' <= length y /\
partial_seq_agreement x y lo hi')
(ensures partial_seq_agreement x y lo hi)
=
()
*)
(*
let lemma_partial_seq_agreement_step (x y z:seq quad32) (lo mid hi:nat) : Lemma
(requires partial_seq_agreement x y lo hi /\
length z >= hi /\
lo <= mid /\ mid < hi /\
(forall i . 0 <= i /\ i < length z /\ (i < lo || i > mid) ==>
index y i == index z i))
(ensures partial_seq_agreement x z (mid+1) hi)
=
()
*)
val gctr_encrypt_block_offset (icb_BE:quad32) (plain_LE:quad32) (alg:algorithm) (key:seq nat32) (i:int) : Lemma
(requires is_aes_key_LE alg key)
(ensures
gctr_encrypt_block icb_BE plain_LE alg key i ==
gctr_encrypt_block (inc32 icb_BE i) plain_LE alg key 0
)
val gctr_encrypt_empty (icb_BE:quad32) (plain_LE cipher_LE:seq quad32) (alg:algorithm) (key:seq nat32) : Lemma
(requires is_aes_key_LE alg key)
(ensures (
let plain = slice (le_seq_quad32_to_bytes plain_LE) 0 0 in
let cipher = slice (le_seq_quad32_to_bytes cipher_LE) 0 0 in
cipher = gctr_encrypt_LE icb_BE (make_gctr_plain_LE plain) alg key
))
let aes_encrypt_BE (alg:algorithm) (key:seq nat32) (p_BE:quad32) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let p_LE = reverse_bytes_quad32 p_BE in
aes_encrypt_LE alg key p_LE
let gctr_registers_def (r0 r1 r2 r3 r4 r5:quad32) (s:seq quad32) (alg:algorithm) (key:seq nat32) (ctr_BE:quad32) (i:int) : prop0 =
0 <= i /\ i*6 + 5 < length s /\
is_aes_key_LE alg key /\
r0 = quad32_xor (index s (i*6 + 0)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 0))) /\
r1 = quad32_xor (index s (i*6 + 1)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 1))) /\
r2 = quad32_xor (index s (i*6 + 2)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 2))) /\
r3 = quad32_xor (index s (i*6 + 3)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 3))) /\
r4 = quad32_xor (index s (i*6 + 4)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 4))) /\ | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.GCTR_s.fst.checked",
"Vale.AES.GCM_helpers.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
_: Vale.Def.Types_s.quad32 ->
_: Vale.Def.Types_s.quad32 ->
_: Vale.Def.Types_s.quad32 ->
_: Vale.Def.Types_s.quad32 ->
_: Vale.Def.Types_s.quad32 ->
_: Vale.Def.Types_s.quad32 ->
_: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
_: Vale.AES.AES_common_s.algorithm ->
_: FStar.Seq.Base.seq Vale.Def.Types_s.nat32 ->
_: Vale.Def.Types_s.quad32 ->
_: Prims.int
-> Vale.Def.Prop_s.prop0 | Prims.Tot | [
"total"
] | [] | [
"Vale.Def.Opaque_s.opaque_make",
"Vale.Def.Types_s.quad32",
"FStar.Seq.Base.seq",
"Vale.AES.AES_common_s.algorithm",
"Vale.Def.Types_s.nat32",
"Prims.int",
"Vale.Def.Prop_s.prop0",
"Vale.AES.GCTR.gctr_registers_def"
] | [] | false | false | false | true | false | let gctr_registers =
| opaque_make gctr_registers_def | false |
|
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.to_mont_lemma | val to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < pow2 (pbits * rLen))
(ensures to_mont pbits rLen n mu a == a * pow2 (pbits * rLen) % n) | val to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < pow2 (pbits * rLen))
(ensures to_mont pbits rLen n mu a == a * pow2 (pbits * rLen) % n) | let to_mont_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let c = a * r2 in
let aM = to_mont pbits rLen n mu a in
assert (aM == mont_reduction pbits rLen n mu c);
mult_lt_lemma a r2 r n;
assert (a * r2 < r * n);
mont_reduction_lemma pbits rLen n mu c;
assert (aM == c * d % n);
to_mont_eval_lemma pbits rLen n mu a;
assert (aM == a * r % n) | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 598,
"start_col": 0,
"start_line": 586
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n))
let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n
val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n))
let mont_mul_lemma pbits rLen n mu a b =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b)
/// Lemma (to_mont rLen n mu a == a * r % n)
val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma
(a * (b % n) * c % n == a * b * c % n)
let lemma_mod_mul_distr3 a b c n =
calc (==) {
a * (b % n) * c % n;
(==) { }
(b % n) * a * c % n;
(==) { Math.Lemmas.paren_mul_right (b % n) a c }
(b % n) * (a * c) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l b (a * c) n }
b * (a * c) % n;
(==) { Math.Lemmas.paren_mul_right b a c }
a * b * c % n;
}
val mult_lt_lemma: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d)
let mult_lt_lemma a b c d = ()
val to_mont_eval_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
a * r2 * d % n == a * r % n))
let to_mont_eval_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let c = a * r2 in
calc (==) {
c * d % n;
(==) { }
a * r2 * d % n;
(==) { Math.Lemmas.paren_mul_right 2 pbits rLen;
Math.Lemmas.pow2_plus (pbits * rLen) (pbits * rLen) }
a * (r * r % n) * d % n;
(==) { lemma_mod_mul_distr3 a (r * r) d n }
a * (r * r) * d % n;
(==) { Math.Lemmas.paren_mul_right a r r }
a * r * r * d % n;
(==) { Math.Lemmas.paren_mul_right (a * r) r d }
a * r * (r * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (a * r) (r * d) n }
a * r * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a * r % n;
};
assert (c * d % n == a * r % n)
val to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < pow2 (pbits * rLen))
(ensures to_mont pbits rLen n mu a == a * pow2 (pbits * rLen) % n) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | pbits: Prims.pos -> rLen: Prims.pos -> n: Prims.pos -> mu: Prims.nat -> a: Prims.nat
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.Montgomery.Lemmas.mont_pre pbits rLen n mu /\ a < Prims.pow2 (pbits * rLen))
(ensures
Hacl.Spec.Montgomery.Lemmas.to_mont pbits rLen n mu a == a * Prims.pow2 (pbits * rLen) % n) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.int",
"Prims._assert",
"Prims.eq2",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Prims.unit",
"Hacl.Spec.Montgomery.Lemmas.to_mont_eval_lemma",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_lemma",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Montgomery.Lemmas.mult_lt_lemma",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction",
"Hacl.Spec.Montgomery.Lemmas.to_mont",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd",
"Prims.pow2"
] | [] | false | false | true | false | false | let to_mont_lemma pbits rLen n mu a =
| let r = pow2 (pbits * rLen) in
let r2 = pow2 ((2 * pbits) * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let c = a * r2 in
let aM = to_mont pbits rLen n mu a in
assert (aM == mont_reduction pbits rLen n mu c);
mult_lt_lemma a r2 r n;
assert (a * r2 < r * n);
mont_reduction_lemma pbits rLen n mu c;
assert (aM == c * d % n);
to_mont_eval_lemma pbits rLen n mu a;
assert (aM == a * r % n) | false |
Vale.AES.GCTR.fsti | Vale.AES.GCTR.gctr_partial | val gctr_partial : _: Vale.AES.AES_common_s.algorithm ->
_: Prims.nat ->
_: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
_: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
_: FStar.Seq.Base.seq Vale.Def.Types_s.nat32 ->
_: Vale.Def.Types_s.quad32
-> Vale.Def.Prop_s.prop0 | let gctr_partial = opaque_make gctr_partial_def | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 97,
"start_col": 19,
"start_line": 97
} | module Vale.AES.GCTR
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
let make_gctr_plain_LE (p:seq nat8) : seq nat8 =
if length p < pow2_32 then p else empty
let inc32lite (cb:quad32) (i:int) : quad32 =
if 0 <= i && i < pow2_32 then
let sum = cb.lo0 + i in
let lo0 = if sum >= pow2_32 then sum - pow2_32 else sum in
Mkfour lo0 cb.lo1 cb.hi2 cb.hi3
else
Mkfour 42 42 42 42
let empty_seq_quad32 : seq quad32 = empty
val lemma_counter_init (x:quad32) (low64 low8:nat64) : Lemma
(requires low64 == lo64 x /\
low8 == iand64 low64 0xff)
(ensures low8 == x.lo0 % 256)
let partial_seq_agreement (x y:seq quad32) (lo hi:nat) =
lo <= hi /\ hi <= length x /\ hi <= length y /\
(forall i . {:pattern (index x i) \/ (index y i)} lo <= i /\ i < hi ==> index x i == index y i)
(*
let lemma_partial_seq_agreement_subset (x y:seq quad32) (lo hi hi':nat) : Lemma
(requires lo <= hi /\ hi <= hi' /\ hi' <= length x /\ hi' <= length y /\
partial_seq_agreement x y lo hi')
(ensures partial_seq_agreement x y lo hi)
=
()
*)
(*
let lemma_partial_seq_agreement_step (x y z:seq quad32) (lo mid hi:nat) : Lemma
(requires partial_seq_agreement x y lo hi /\
length z >= hi /\
lo <= mid /\ mid < hi /\
(forall i . 0 <= i /\ i < length z /\ (i < lo || i > mid) ==>
index y i == index z i))
(ensures partial_seq_agreement x z (mid+1) hi)
=
()
*)
val gctr_encrypt_block_offset (icb_BE:quad32) (plain_LE:quad32) (alg:algorithm) (key:seq nat32) (i:int) : Lemma
(requires is_aes_key_LE alg key)
(ensures
gctr_encrypt_block icb_BE plain_LE alg key i ==
gctr_encrypt_block (inc32 icb_BE i) plain_LE alg key 0
)
val gctr_encrypt_empty (icb_BE:quad32) (plain_LE cipher_LE:seq quad32) (alg:algorithm) (key:seq nat32) : Lemma
(requires is_aes_key_LE alg key)
(ensures (
let plain = slice (le_seq_quad32_to_bytes plain_LE) 0 0 in
let cipher = slice (le_seq_quad32_to_bytes cipher_LE) 0 0 in
cipher = gctr_encrypt_LE icb_BE (make_gctr_plain_LE plain) alg key
))
let aes_encrypt_BE (alg:algorithm) (key:seq nat32) (p_BE:quad32) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let p_LE = reverse_bytes_quad32 p_BE in
aes_encrypt_LE alg key p_LE
let gctr_registers_def (r0 r1 r2 r3 r4 r5:quad32) (s:seq quad32) (alg:algorithm) (key:seq nat32) (ctr_BE:quad32) (i:int) : prop0 =
0 <= i /\ i*6 + 5 < length s /\
is_aes_key_LE alg key /\
r0 = quad32_xor (index s (i*6 + 0)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 0))) /\
r1 = quad32_xor (index s (i*6 + 1)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 1))) /\
r2 = quad32_xor (index s (i*6 + 2)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 2))) /\
r3 = quad32_xor (index s (i*6 + 3)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 3))) /\
r4 = quad32_xor (index s (i*6 + 4)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 4))) /\
r5 = quad32_xor (index s (i*6 + 5)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 5)))
[@"opaque_to_smt"] let gctr_registers = opaque_make gctr_registers_def
irreducible let gctr_registers_reveal = opaque_revealer (`%gctr_registers) gctr_registers gctr_registers_def
let gctr_partial_def (alg:algorithm) (bound:nat) (plain cipher:seq quad32) (key:seq nat32) (icb:quad32) : prop0 =
is_aes_key_LE alg key /\
( let bound = min bound (min (length plain) (length cipher)) in
forall j . {:pattern (index cipher j)} 0 <= j /\ j < bound ==> | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.GCTR_s.fst.checked",
"Vale.AES.GCM_helpers.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
_: Vale.AES.AES_common_s.algorithm ->
_: Prims.nat ->
_: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
_: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
_: FStar.Seq.Base.seq Vale.Def.Types_s.nat32 ->
_: Vale.Def.Types_s.quad32
-> Vale.Def.Prop_s.prop0 | Prims.Tot | [
"total"
] | [] | [
"Vale.Def.Opaque_s.opaque_make",
"Vale.AES.AES_common_s.algorithm",
"Prims.nat",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.nat32",
"Vale.Def.Prop_s.prop0",
"Vale.AES.GCTR.gctr_partial_def"
] | [] | false | false | false | true | false | let gctr_partial =
| opaque_make gctr_partial_def | false |
|
Vale.AES.GCTR.fsti | Vale.AES.GCTR.gctr_partial_reveal | val gctr_partial_reveal : _: Prims.unit
-> FStar.Pervasives.Lemma (ensures Vale.AES.GCTR.gctr_partial == Vale.AES.GCTR.gctr_partial_def) | let gctr_partial_reveal = opaque_revealer (`%gctr_partial) gctr_partial gctr_partial_def | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 100,
"end_line": 98,
"start_col": 12,
"start_line": 98
} | module Vale.AES.GCTR
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
let make_gctr_plain_LE (p:seq nat8) : seq nat8 =
if length p < pow2_32 then p else empty
let inc32lite (cb:quad32) (i:int) : quad32 =
if 0 <= i && i < pow2_32 then
let sum = cb.lo0 + i in
let lo0 = if sum >= pow2_32 then sum - pow2_32 else sum in
Mkfour lo0 cb.lo1 cb.hi2 cb.hi3
else
Mkfour 42 42 42 42
let empty_seq_quad32 : seq quad32 = empty
val lemma_counter_init (x:quad32) (low64 low8:nat64) : Lemma
(requires low64 == lo64 x /\
low8 == iand64 low64 0xff)
(ensures low8 == x.lo0 % 256)
let partial_seq_agreement (x y:seq quad32) (lo hi:nat) =
lo <= hi /\ hi <= length x /\ hi <= length y /\
(forall i . {:pattern (index x i) \/ (index y i)} lo <= i /\ i < hi ==> index x i == index y i)
(*
let lemma_partial_seq_agreement_subset (x y:seq quad32) (lo hi hi':nat) : Lemma
(requires lo <= hi /\ hi <= hi' /\ hi' <= length x /\ hi' <= length y /\
partial_seq_agreement x y lo hi')
(ensures partial_seq_agreement x y lo hi)
=
()
*)
(*
let lemma_partial_seq_agreement_step (x y z:seq quad32) (lo mid hi:nat) : Lemma
(requires partial_seq_agreement x y lo hi /\
length z >= hi /\
lo <= mid /\ mid < hi /\
(forall i . 0 <= i /\ i < length z /\ (i < lo || i > mid) ==>
index y i == index z i))
(ensures partial_seq_agreement x z (mid+1) hi)
=
()
*)
val gctr_encrypt_block_offset (icb_BE:quad32) (plain_LE:quad32) (alg:algorithm) (key:seq nat32) (i:int) : Lemma
(requires is_aes_key_LE alg key)
(ensures
gctr_encrypt_block icb_BE plain_LE alg key i ==
gctr_encrypt_block (inc32 icb_BE i) plain_LE alg key 0
)
val gctr_encrypt_empty (icb_BE:quad32) (plain_LE cipher_LE:seq quad32) (alg:algorithm) (key:seq nat32) : Lemma
(requires is_aes_key_LE alg key)
(ensures (
let plain = slice (le_seq_quad32_to_bytes plain_LE) 0 0 in
let cipher = slice (le_seq_quad32_to_bytes cipher_LE) 0 0 in
cipher = gctr_encrypt_LE icb_BE (make_gctr_plain_LE plain) alg key
))
let aes_encrypt_BE (alg:algorithm) (key:seq nat32) (p_BE:quad32) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let p_LE = reverse_bytes_quad32 p_BE in
aes_encrypt_LE alg key p_LE
let gctr_registers_def (r0 r1 r2 r3 r4 r5:quad32) (s:seq quad32) (alg:algorithm) (key:seq nat32) (ctr_BE:quad32) (i:int) : prop0 =
0 <= i /\ i*6 + 5 < length s /\
is_aes_key_LE alg key /\
r0 = quad32_xor (index s (i*6 + 0)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 0))) /\
r1 = quad32_xor (index s (i*6 + 1)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 1))) /\
r2 = quad32_xor (index s (i*6 + 2)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 2))) /\
r3 = quad32_xor (index s (i*6 + 3)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 3))) /\
r4 = quad32_xor (index s (i*6 + 4)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 4))) /\
r5 = quad32_xor (index s (i*6 + 5)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 5)))
[@"opaque_to_smt"] let gctr_registers = opaque_make gctr_registers_def
irreducible let gctr_registers_reveal = opaque_revealer (`%gctr_registers) gctr_registers gctr_registers_def
let gctr_partial_def (alg:algorithm) (bound:nat) (plain cipher:seq quad32) (key:seq nat32) (icb:quad32) : prop0 =
is_aes_key_LE alg key /\
( let bound = min bound (min (length plain) (length cipher)) in
forall j . {:pattern (index cipher j)} 0 <= j /\ j < bound ==>
index cipher j == quad32_xor (index plain j) (aes_encrypt_BE alg key (inc32 icb j))) | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.GCTR_s.fst.checked",
"Vale.AES.GCM_helpers.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma (ensures Vale.AES.GCTR.gctr_partial == Vale.AES.GCTR.gctr_partial_def) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Opaque_s.opaque_revealer",
"Vale.AES.AES_common_s.algorithm",
"Prims.nat",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.nat32",
"Vale.Def.Prop_s.prop0",
"Vale.AES.GCTR.gctr_partial",
"Vale.AES.GCTR.gctr_partial_def"
] | [] | true | false | true | false | false | let gctr_partial_reveal =
| opaque_revealer (`%gctr_partial) gctr_partial gctr_partial_def | false |
|
Spec.Poly1305.Test.fst | Spec.Poly1305.Test.key | val key:lbytes 32 | val key:lbytes 32 | let key : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy;
0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy;
0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy;
0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"file_name": "specs/tests/Spec.Poly1305.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 38,
"start_col": 0,
"start_line": 30
} | module Spec.Poly1305.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Poly1305
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(* ********************* *)
(* RFC 7539 Test Vectors *)
(* ********************* *)
let msg : lbytes 34 =
let l = List.Tot.map u8_from_UInt8 [
0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy;
0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy;
0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy;
0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy;
0x75uy; 0x70uy
] in
assert_norm (List.Tot.length l == 34);
of_list l | {
"checked_file": "/",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.IO.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Poly1305.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Poly1305",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 32 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let key:lbytes 32 =
| let l =
List.Tot.map u8_from_UInt8
[
0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy;
0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy;
0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy
]
in
assert_norm (List.Tot.length l == 32);
of_list l | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.from_mont_one_lemma | val from_mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires
mont_pre pbits rLen n mu)
(ensures
(let oneM = mont_one pbits rLen n mu in
let one = from_mont pbits rLen n mu oneM in
one == 1)) | val from_mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires
mont_pre pbits rLen n mu)
(ensures
(let oneM = mont_one pbits rLen n mu in
let one = from_mont pbits rLen n mu oneM in
one == 1)) | let from_mont_one_lemma pbits rLen n mu =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let oneM = mont_one pbits rLen n mu in
mont_one_lemma pbits rLen n mu;
assert (oneM == r % n);
let one = from_mont pbits rLen n mu oneM in
from_mont_lemma pbits rLen n mu oneM;
assert (one == oneM * d % n);
assert (one == (r % n) * d % n);
lemma_mont_id n r d 1;
assert (one == 1 % n);
Math.Lemmas.small_mod 1 n | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 824,
"start_col": 0,
"start_line": 810
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n))
let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n
val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n))
let mont_mul_lemma pbits rLen n mu a b =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b)
/// Lemma (to_mont rLen n mu a == a * r % n)
val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma
(a * (b % n) * c % n == a * b * c % n)
let lemma_mod_mul_distr3 a b c n =
calc (==) {
a * (b % n) * c % n;
(==) { }
(b % n) * a * c % n;
(==) { Math.Lemmas.paren_mul_right (b % n) a c }
(b % n) * (a * c) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l b (a * c) n }
b * (a * c) % n;
(==) { Math.Lemmas.paren_mul_right b a c }
a * b * c % n;
}
val mult_lt_lemma: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d)
let mult_lt_lemma a b c d = ()
val to_mont_eval_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
a * r2 * d % n == a * r % n))
let to_mont_eval_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let c = a * r2 in
calc (==) {
c * d % n;
(==) { }
a * r2 * d % n;
(==) { Math.Lemmas.paren_mul_right 2 pbits rLen;
Math.Lemmas.pow2_plus (pbits * rLen) (pbits * rLen) }
a * (r * r % n) * d % n;
(==) { lemma_mod_mul_distr3 a (r * r) d n }
a * (r * r) * d % n;
(==) { Math.Lemmas.paren_mul_right a r r }
a * r * r * d % n;
(==) { Math.Lemmas.paren_mul_right (a * r) r d }
a * r * (r * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (a * r) (r * d) n }
a * r * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a * r % n;
};
assert (c * d % n == a * r % n)
val to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < pow2 (pbits * rLen))
(ensures to_mont pbits rLen n mu a == a * pow2 (pbits * rLen) % n)
let to_mont_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let c = a * r2 in
let aM = to_mont pbits rLen n mu a in
assert (aM == mont_reduction pbits rLen n mu c);
mult_lt_lemma a r2 r n;
assert (a * r2 < r * n);
mont_reduction_lemma pbits rLen n mu c;
assert (aM == c * d % n);
to_mont_eval_lemma pbits rLen n mu a;
assert (aM == a * r % n)
/// Lemma (from_mont rLen n mu aM == aM * d % n)
val from_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ aM < pow2 (pbits * rLen))
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
from_mont pbits rLen n mu aM == aM * d % n))
let from_mont_lemma pbits rLen n mu aM =
mont_reduction_lemma pbits rLen n mu aM
/// Lemma (mont_one pbits rLen n mu == 1 * r % n)
val mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures mont_one pbits rLen n mu == 1 * pow2 (pbits * rLen) % n)
let mont_one_lemma pbits rLen n mu =
to_mont_lemma pbits rLen n mu 1
/// Properties of Montgomery arithmetic
// from_mont (to_mont a) = a % n
val lemma_mont_id: n:pos -> r:pos -> d:int{r * d % n == 1} -> a:nat ->
Lemma (a * r % n * d % n == a % n)
let lemma_mont_id n r d a =
calc (==) {
a * r % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * r) d n }
a * r * d % n;
(==) { Math.Lemmas.paren_mul_right a r d; Math.Lemmas.lemma_mod_mul_distr_r a (r * d) n }
a * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a % n;
}
// to_mont (mont_reduction a) = a % n
val lemma_mont_id1: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (a * d % n * r % n == a % n)
let lemma_mont_id1 n r d a =
calc (==) {
((a * d % n) * r) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * d) r n }
((a * d) * r) % n;
(==) { Math.Lemmas.paren_mul_right a d r }
(a * (d * r)) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r a (d * r) n }
(a * (d * r % n)) % n;
(==) { assert (r * d % n = 1) }
a % n;
};
assert (a * d % n * r % n == a % n)
// one_M * a = a
val lemma_mont_mul_one: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (let r0 = 1 * r % n in let r1 = a * r % n in r0 * r1 * d % n == r1 % n)
let lemma_mont_mul_one n r d a =
let r0 = 1 * r % n in
let r1 = a * r % n in
calc (==) {
r1 * r0 * d % n;
(==) { Math.Lemmas.paren_mul_right r1 r0 d; Math.Lemmas.lemma_mod_mul_distr_r r1 (r0 * d) n }
r1 * (r0 * d % n) % n;
(==) { lemma_mont_id n r d 1 }
r1 * (1 % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r r1 1 n }
r1 % n;
}
val from_mont_add_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = (aM + bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == (a + b) % n))
let from_mont_add_lemma pbits rLen n mu aM bM =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = (aM + bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
from_mont_lemma pbits rLen n mu cM;
assert (c == cM * d % n);
calc (==) { //c
cM * d % n;
(==) { }
(aM + bM) % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM + bM) d n }
(aM + bM) * d % n;
(==) { Math.Lemmas.distributivity_add_left aM bM d }
(aM * d + bM * d) % n;
(==) { Math.Lemmas.modulo_distributivity (aM * d) (bM * d) n }
(aM * d % n + bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM
val from_mont_sub_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = (aM - bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == (a - b) % n))
let from_mont_sub_lemma pbits rLen n mu aM bM =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = (aM - bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
from_mont_lemma pbits rLen n mu cM;
assert (c == cM * d % n);
calc (==) { //c
cM * d % n;
(==) { }
(aM - bM) % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM - bM) d n }
(aM - bM) * d % n;
(==) { Math.Lemmas.distributivity_sub_left aM bM d }
(aM * d - bM * d) % n;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (aM * d) (- bM * d) n }
(aM * d % n - bM * d) % n;
(==) { Math.Lemmas.lemma_mod_sub_distr (aM * d % n) (bM * d) n }
(aM * d % n - bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM
val from_mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = mont_mul pbits rLen n mu aM bM in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == a * b % n))
let from_mont_mul_lemma pbits rLen n mu aM bM =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = mont_mul pbits rLen n mu aM bM in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
mont_mul_lemma pbits rLen n mu aM bM;
assert (cM == aM * bM * d % n);
from_mont_lemma pbits rLen n mu cM;
calc (==) { //c
cM * d % n;
(==) { }
(aM * bM * d % n) * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM * bM * d) d n }
aM * bM * d * d % n;
(==) { Math.Lemmas.paren_mul_right aM bM d }
aM * (bM * d) * d % n;
(==) {
Math.Lemmas.paren_mul_right aM (bM * d) d;
Math.Lemmas.swap_mul (bM * d) d;
Math.Lemmas.paren_mul_right aM d (bM * d) }
aM * d * (bM * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM * d) (bM * d) n }
(aM * d % n) * (bM * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (aM * d % n) (bM * d) n }
(aM * d % n) * (bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM
val from_mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires
mont_pre pbits rLen n mu)
(ensures
(let oneM = mont_one pbits rLen n mu in
let one = from_mont pbits rLen n mu oneM in
one == 1)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | pbits: Prims.pos -> rLen: Prims.pos -> n: Prims.pos -> mu: Prims.nat
-> FStar.Pervasives.Lemma (requires Hacl.Spec.Montgomery.Lemmas.mont_pre pbits rLen n mu)
(ensures
(let oneM = Hacl.Spec.Montgomery.Lemmas.mont_one pbits rLen n mu in
let one = Hacl.Spec.Montgomery.Lemmas.from_mont pbits rLen n mu oneM in
one == 1)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.int",
"FStar.Math.Lemmas.small_mod",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.op_Modulus",
"Hacl.Spec.Montgomery.Lemmas.lemma_mont_id",
"FStar.Mul.op_Star",
"Hacl.Spec.Montgomery.Lemmas.from_mont_lemma",
"Hacl.Spec.Montgomery.Lemmas.from_mont",
"Hacl.Spec.Montgomery.Lemmas.mont_one_lemma",
"Hacl.Spec.Montgomery.Lemmas.mont_one",
"Hacl.Spec.Montgomery.Lemmas.mont_preconditions_d",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd",
"Prims.pow2"
] | [] | false | false | true | false | false | let from_mont_one_lemma pbits rLen n mu =
| let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let oneM = mont_one pbits rLen n mu in
mont_one_lemma pbits rLen n mu;
assert (oneM == r % n);
let one = from_mont pbits rLen n mu oneM in
from_mont_lemma pbits rLen n mu oneM;
assert (one == oneM * d % n);
assert (one == (r % n) * d % n);
lemma_mont_id n r d 1;
assert (one == 1 % n);
Math.Lemmas.small_mod 1 n | false |
Spec.Poly1305.Test.fst | Spec.Poly1305.Test.expected | val expected:lbytes 16 | val expected:lbytes 16 | let expected : lbytes 16 =
let l = List.Tot.map u8_from_UInt8 [
0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy;
0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy
] in
assert_norm (List.Tot.length l == 16);
of_list l | {
"file_name": "specs/tests/Spec.Poly1305.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 47,
"start_col": 0,
"start_line": 41
} | module Spec.Poly1305.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Poly1305
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(* ********************* *)
(* RFC 7539 Test Vectors *)
(* ********************* *)
let msg : lbytes 34 =
let l = List.Tot.map u8_from_UInt8 [
0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy;
0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy;
0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy;
0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy;
0x75uy; 0x70uy
] in
assert_norm (List.Tot.length l == 34);
of_list l
let key : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy;
0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy;
0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy;
0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"checked_file": "/",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.IO.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Poly1305.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Poly1305",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 16 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let expected:lbytes 16 =
| let l =
List.Tot.map u8_from_UInt8
[
0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy;
0x0cuy; 0x01uy; 0x27uy; 0xa9uy
]
in
assert_norm (List.Tot.length l == 16);
of_list l | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.mont_reduction_lemma_step_bound_aux | val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n) | val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n) | let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
} | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 273,
"start_col": 0,
"start_line": 249
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
pbits: Prims.pos ->
n: Prims.pos ->
q_i: Prims.nat{q_i < Prims.pow2 pbits} ->
i: Prims.pos ->
c: Prims.nat ->
res0: Prims.nat
-> FStar.Pervasives.Lemma (requires res0 <= c + (Prims.pow2 (pbits * (i - 1)) - 1) * n)
(ensures
res0 + (n * q_i) * Prims.pow2 (pbits * (i - 1)) <= c + (Prims.pow2 (pbits * i) - 1) * n) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.eq2",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.lemma_mult_le_right",
"Prims.squash",
"FStar.Math.Lemmas.paren_mul_right",
"FStar.Math.Lemmas.distributivity_sub_left",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.distributivity_sub_right"
] | [] | false | false | true | false | false | let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
| let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc ( <= ) {
res0 + (n * q_i) * b1;
( <= ) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + (n * (pow2 pbits - 1)) * b1;
( == ) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
( == ) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
( == ) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
( == ) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
( <= ) { () }
c + (b1 - 1) * n + n * b - n * b1;
( == ) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
( == ) { () }
c - n + b * n;
( == ) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
} | false |
Vale.AES.GCTR.fsti | Vale.AES.GCTR.inc32lite | val inc32lite (cb: quad32) (i: int) : quad32 | val inc32lite (cb: quad32) (i: int) : quad32 | let inc32lite (cb:quad32) (i:int) : quad32 =
if 0 <= i && i < pow2_32 then
let sum = cb.lo0 + i in
let lo0 = if sum >= pow2_32 then sum - pow2_32 else sum in
Mkfour lo0 cb.lo1 cb.hi2 cb.hi3
else
Mkfour 42 42 42 42 | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 25,
"start_col": 0,
"start_line": 19
} | module Vale.AES.GCTR
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
let make_gctr_plain_LE (p:seq nat8) : seq nat8 =
if length p < pow2_32 then p else empty | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.GCTR_s.fst.checked",
"Vale.AES.GCM_helpers.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | cb: Vale.Def.Types_s.quad32 -> i: Prims.int -> Vale.Def.Types_s.quad32 | Prims.Tot | [
"total"
] | [] | [
"Vale.Def.Types_s.quad32",
"Prims.int",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Vale.Def.Words_s.pow2_32",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Words_s.nat32",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Subtraction",
"Prims.bool",
"Prims.op_Addition",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0"
] | [] | false | false | false | true | false | let inc32lite (cb: quad32) (i: int) : quad32 =
| if 0 <= i && i < pow2_32
then
let sum = cb.lo0 + i in
let lo0 = if sum >= pow2_32 then sum - pow2_32 else sum in
Mkfour lo0 cb.lo1 cb.hi2 cb.hi3
else Mkfour 42 42 42 42 | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.from_to_mont_lemma | val from_to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
mont_pre pbits rLen n mu /\ a < r))
(ensures
(let aM = to_mont pbits rLen n mu a in
let a' = from_mont pbits rLen n mu aM in
a' == a % n)) | val from_to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
mont_pre pbits rLen n mu /\ a < r))
(ensures
(let aM = to_mont pbits rLen n mu a in
let a' = from_mont pbits rLen n mu aM in
a' == a % n)) | let from_to_mont_lemma pbits rLen n mu a =
let aM = to_mont pbits rLen n mu a in
let a' = from_mont pbits rLen n mu aM in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
assert (r * d % n == 1);
to_mont_lemma pbits rLen n mu a;
assert (aM == a * r % n);
from_mont_lemma pbits rLen n mu aM;
assert (a' == aM * d % n);
lemma_mont_id n r d a;
assert (a' == a % n) | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 850,
"start_col": 0,
"start_line": 835
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n))
let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n
val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n))
let mont_mul_lemma pbits rLen n mu a b =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b)
/// Lemma (to_mont rLen n mu a == a * r % n)
val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma
(a * (b % n) * c % n == a * b * c % n)
let lemma_mod_mul_distr3 a b c n =
calc (==) {
a * (b % n) * c % n;
(==) { }
(b % n) * a * c % n;
(==) { Math.Lemmas.paren_mul_right (b % n) a c }
(b % n) * (a * c) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l b (a * c) n }
b * (a * c) % n;
(==) { Math.Lemmas.paren_mul_right b a c }
a * b * c % n;
}
val mult_lt_lemma: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d)
let mult_lt_lemma a b c d = ()
val to_mont_eval_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
a * r2 * d % n == a * r % n))
let to_mont_eval_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let c = a * r2 in
calc (==) {
c * d % n;
(==) { }
a * r2 * d % n;
(==) { Math.Lemmas.paren_mul_right 2 pbits rLen;
Math.Lemmas.pow2_plus (pbits * rLen) (pbits * rLen) }
a * (r * r % n) * d % n;
(==) { lemma_mod_mul_distr3 a (r * r) d n }
a * (r * r) * d % n;
(==) { Math.Lemmas.paren_mul_right a r r }
a * r * r * d % n;
(==) { Math.Lemmas.paren_mul_right (a * r) r d }
a * r * (r * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (a * r) (r * d) n }
a * r * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a * r % n;
};
assert (c * d % n == a * r % n)
val to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < pow2 (pbits * rLen))
(ensures to_mont pbits rLen n mu a == a * pow2 (pbits * rLen) % n)
let to_mont_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let c = a * r2 in
let aM = to_mont pbits rLen n mu a in
assert (aM == mont_reduction pbits rLen n mu c);
mult_lt_lemma a r2 r n;
assert (a * r2 < r * n);
mont_reduction_lemma pbits rLen n mu c;
assert (aM == c * d % n);
to_mont_eval_lemma pbits rLen n mu a;
assert (aM == a * r % n)
/// Lemma (from_mont rLen n mu aM == aM * d % n)
val from_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ aM < pow2 (pbits * rLen))
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
from_mont pbits rLen n mu aM == aM * d % n))
let from_mont_lemma pbits rLen n mu aM =
mont_reduction_lemma pbits rLen n mu aM
/// Lemma (mont_one pbits rLen n mu == 1 * r % n)
val mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures mont_one pbits rLen n mu == 1 * pow2 (pbits * rLen) % n)
let mont_one_lemma pbits rLen n mu =
to_mont_lemma pbits rLen n mu 1
/// Properties of Montgomery arithmetic
// from_mont (to_mont a) = a % n
val lemma_mont_id: n:pos -> r:pos -> d:int{r * d % n == 1} -> a:nat ->
Lemma (a * r % n * d % n == a % n)
let lemma_mont_id n r d a =
calc (==) {
a * r % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * r) d n }
a * r * d % n;
(==) { Math.Lemmas.paren_mul_right a r d; Math.Lemmas.lemma_mod_mul_distr_r a (r * d) n }
a * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a % n;
}
// to_mont (mont_reduction a) = a % n
val lemma_mont_id1: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (a * d % n * r % n == a % n)
let lemma_mont_id1 n r d a =
calc (==) {
((a * d % n) * r) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * d) r n }
((a * d) * r) % n;
(==) { Math.Lemmas.paren_mul_right a d r }
(a * (d * r)) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r a (d * r) n }
(a * (d * r % n)) % n;
(==) { assert (r * d % n = 1) }
a % n;
};
assert (a * d % n * r % n == a % n)
// one_M * a = a
val lemma_mont_mul_one: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (let r0 = 1 * r % n in let r1 = a * r % n in r0 * r1 * d % n == r1 % n)
let lemma_mont_mul_one n r d a =
let r0 = 1 * r % n in
let r1 = a * r % n in
calc (==) {
r1 * r0 * d % n;
(==) { Math.Lemmas.paren_mul_right r1 r0 d; Math.Lemmas.lemma_mod_mul_distr_r r1 (r0 * d) n }
r1 * (r0 * d % n) % n;
(==) { lemma_mont_id n r d 1 }
r1 * (1 % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r r1 1 n }
r1 % n;
}
val from_mont_add_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = (aM + bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == (a + b) % n))
let from_mont_add_lemma pbits rLen n mu aM bM =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = (aM + bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
from_mont_lemma pbits rLen n mu cM;
assert (c == cM * d % n);
calc (==) { //c
cM * d % n;
(==) { }
(aM + bM) % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM + bM) d n }
(aM + bM) * d % n;
(==) { Math.Lemmas.distributivity_add_left aM bM d }
(aM * d + bM * d) % n;
(==) { Math.Lemmas.modulo_distributivity (aM * d) (bM * d) n }
(aM * d % n + bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM
val from_mont_sub_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = (aM - bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == (a - b) % n))
let from_mont_sub_lemma pbits rLen n mu aM bM =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = (aM - bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
from_mont_lemma pbits rLen n mu cM;
assert (c == cM * d % n);
calc (==) { //c
cM * d % n;
(==) { }
(aM - bM) % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM - bM) d n }
(aM - bM) * d % n;
(==) { Math.Lemmas.distributivity_sub_left aM bM d }
(aM * d - bM * d) % n;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (aM * d) (- bM * d) n }
(aM * d % n - bM * d) % n;
(==) { Math.Lemmas.lemma_mod_sub_distr (aM * d % n) (bM * d) n }
(aM * d % n - bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM
val from_mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = mont_mul pbits rLen n mu aM bM in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == a * b % n))
let from_mont_mul_lemma pbits rLen n mu aM bM =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = mont_mul pbits rLen n mu aM bM in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
mont_mul_lemma pbits rLen n mu aM bM;
assert (cM == aM * bM * d % n);
from_mont_lemma pbits rLen n mu cM;
calc (==) { //c
cM * d % n;
(==) { }
(aM * bM * d % n) * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM * bM * d) d n }
aM * bM * d * d % n;
(==) { Math.Lemmas.paren_mul_right aM bM d }
aM * (bM * d) * d % n;
(==) {
Math.Lemmas.paren_mul_right aM (bM * d) d;
Math.Lemmas.swap_mul (bM * d) d;
Math.Lemmas.paren_mul_right aM d (bM * d) }
aM * d * (bM * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM * d) (bM * d) n }
(aM * d % n) * (bM * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (aM * d % n) (bM * d) n }
(aM * d % n) * (bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM
val from_mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires
mont_pre pbits rLen n mu)
(ensures
(let oneM = mont_one pbits rLen n mu in
let one = from_mont pbits rLen n mu oneM in
one == 1))
let from_mont_one_lemma pbits rLen n mu =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let oneM = mont_one pbits rLen n mu in
mont_one_lemma pbits rLen n mu;
assert (oneM == r % n);
let one = from_mont pbits rLen n mu oneM in
from_mont_lemma pbits rLen n mu oneM;
assert (one == oneM * d % n);
assert (one == (r % n) * d % n);
lemma_mont_id n r d 1;
assert (one == 1 % n);
Math.Lemmas.small_mod 1 n
val from_to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
mont_pre pbits rLen n mu /\ a < r))
(ensures
(let aM = to_mont pbits rLen n mu a in
let a' = from_mont pbits rLen n mu aM in
a' == a % n)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | pbits: Prims.pos -> rLen: Prims.pos -> n: Prims.pos -> mu: Prims.nat -> a: Prims.nat
-> FStar.Pervasives.Lemma
(requires
(let r = Prims.pow2 (pbits * rLen) in
Hacl.Spec.Montgomery.Lemmas.mont_pre pbits rLen n mu /\ a < r))
(ensures
(let aM = Hacl.Spec.Montgomery.Lemmas.to_mont pbits rLen n mu a in
let a' = Hacl.Spec.Montgomery.Lemmas.from_mont pbits rLen n mu aM in
a' == a % n)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.int",
"Prims._assert",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.unit",
"Hacl.Spec.Montgomery.Lemmas.lemma_mont_id",
"FStar.Mul.op_Star",
"Hacl.Spec.Montgomery.Lemmas.from_mont_lemma",
"Hacl.Spec.Montgomery.Lemmas.to_mont_lemma",
"Hacl.Spec.Montgomery.Lemmas.mont_preconditions_d",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd",
"Prims.pow2",
"Hacl.Spec.Montgomery.Lemmas.from_mont",
"Hacl.Spec.Montgomery.Lemmas.to_mont"
] | [] | false | false | true | false | false | let from_to_mont_lemma pbits rLen n mu a =
| let aM = to_mont pbits rLen n mu a in
let a' = from_mont pbits rLen n mu aM in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
assert (r * d % n == 1);
to_mont_lemma pbits rLen n mu a;
assert (aM == a * r % n);
from_mont_lemma pbits rLen n mu aM;
assert (a' == aM * d % n);
lemma_mont_id n r d a;
assert (a' == a % n) | false |
Hacl.Bignum.MontArithmetic.fsti | Hacl.Bignum.MontArithmetic.bn_field_exp_vartime_st | val bn_field_exp_vartime_st : t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | let bn_field_exp_vartime_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> bBits:size_t
-> b:lbignum t (blocks0 bBits (size (bits t)))
-> resM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
bn_v h b < pow2 (v bBits) /\
live h aM /\ live h b /\ live h resM /\
disjoint resM aM /\ disjoint resM b /\ disjoint aM b /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (resM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc resM) h0 h1 /\
bn_v h1 resM < bn_v_n h0 k /\
as_seq h1 resM == S.bn_field_exp_vartime (as_pctx h0 k) (as_seq h0 aM) (v bBits) (as_seq h0 b)) | {
"file_name": "code/bignum/Hacl.Bignum.MontArithmetic.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 99,
"end_line": 395,
"start_col": 0,
"start_line": 376
} | module Hacl.Bignum.MontArithmetic
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module B = LowStar.Buffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module Euclid = FStar.Math.Euclid
module S = Hacl.Spec.Bignum.MontArithmetic
module BE = Hacl.Bignum.Exponentiation
module BN = Hacl.Bignum
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val _align_fsti : unit
inline_for_extraction noextract
let lb (t:limb_t) =
match t with
| U32 -> buffer uint32
| U64 -> buffer uint64
inline_for_extraction noextract
let ll (t:limb_t) =
match t with
| U32 -> uint32
| U64 -> uint64
inline_for_extraction
noeq
type bn_mont_ctx' (t:limb_t) (a:Type0{a == lb t}) (b:Type0{b == ll t}) = {
len: BN.meta_len t;
n: x:a{length #MUT #(limb t) x == v len};
mu: b;
r2: x:a{length #MUT #(limb t) x == v len};
}
inline_for_extraction noextract
let bn_mont_ctx (t:limb_t) = bn_mont_ctx' t (lb t) (ll t)
let bn_mont_ctx_u32 = bn_mont_ctx' U32 (lb U32) (ll U32)
let bn_mont_ctx_u64 = bn_mont_ctx' U64 (lb U64) (ll U64)
inline_for_extraction noextract
let pbn_mont_ctx (t:limb_t) = B.pointer (bn_mont_ctx t)
inline_for_extraction noextract
let pbn_mont_ctx_u32 = B.pointer bn_mont_ctx_u32
inline_for_extraction noextract
let pbn_mont_ctx_u64 = B.pointer bn_mont_ctx_u64
inline_for_extraction noextract
let as_ctx (#t:limb_t) (h:mem) (k:bn_mont_ctx t) : GTot (S.bn_mont_ctx t) = {
S.len = v k.len;
S.n = as_seq h (k.n <: lbignum t k.len);
S.mu = k.mu;
S.r2 = as_seq h (k.r2 <: lbignum t k.len);
}
inline_for_extraction noextract
let bn_mont_ctx_inv (#t:limb_t) (h:mem) (k:bn_mont_ctx t) =
let n : buffer (limb t) = k.n in
let r2 : buffer (limb t) = k.r2 in
live h n /\ live h r2 /\ disjoint n r2 /\
S.bn_mont_ctx_inv (as_ctx h k)
inline_for_extraction noextract
let bn_v_n (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) =
let k1 = B.deref h k in
let n : lbignum t k1.len = k1.n in
bn_v h n
inline_for_extraction noextract
let freeable_s (#t:limb_t) (h:mem) (k:bn_mont_ctx t) =
let n : buffer (limb t) = k.n in
let r2 : buffer (limb t) = k.r2 in
B.freeable n /\ B.freeable r2
inline_for_extraction noextract
let freeable (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) =
B.freeable k /\ freeable_s h (B.deref h k)
inline_for_extraction noextract
let footprint_s (#t:limb_t) (h:mem) (k:bn_mont_ctx t) =
let n : buffer (limb t) = k.n in
let r2 : buffer (limb t) = k.r2 in
B.(loc_union (loc_addr_of_buffer n) (loc_addr_of_buffer r2))
inline_for_extraction noextract
let footprint (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) =
B.(loc_union (loc_addr_of_buffer k) (footprint_s h (B.deref h k)))
inline_for_extraction noextract
let as_pctx (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) : GTot (S.bn_mont_ctx t) =
as_ctx h (B.deref h k)
inline_for_extraction noextract
let pbn_mont_ctx_inv (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) =
B.live h k /\
B.(loc_disjoint (loc_addr_of_buffer k) (footprint_s h (B.deref h k))) /\
bn_mont_ctx_inv h (B.deref h k)
inline_for_extraction noextract
let bn_field_get_len_st (t:limb_t) = k:pbn_mont_ctx t ->
Stack (BN.meta_len t)
(requires fun h -> pbn_mont_ctx_inv h k)
(ensures fun h0 r h1 -> h0 == h1 /\
r == (B.deref h0 k).len /\
v r == S.bn_field_get_len (as_pctx h0 k))
inline_for_extraction noextract
val bn_field_get_len: #t:limb_t -> bn_field_get_len_st t
inline_for_extraction noextract
let bn_field_check_modulus_st (t:limb_t) (len:BN.meta_len t) = n:lbignum t len ->
Stack bool
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == S.bn_field_check_modulus (as_seq h0 n))
inline_for_extraction noextract
val bn_field_check_modulus: #t:limb_t -> km:BM.mont t -> bn_field_check_modulus_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_init_st (t:limb_t) (len:BN.meta_len t) =
r:HS.rid
-> n:lbignum t len ->
ST (pbn_mont_ctx t)
(requires fun h ->
S.bn_mont_ctx_pre (as_seq h n) /\
live h n /\ ST.is_eternal_region r)
(ensures fun h0 res h1 ->
B.(modifies loc_none h0 h1) /\
B.(fresh_loc (footprint h1 res) h0 h1) /\
B.(loc_includes (loc_region_only true r) (footprint h1 res)) /\
freeable h1 res /\
(B.deref h1 res).len == len /\ bn_v_n h1 res == bn_v h0 n /\
S.bn_mont_ctx_inv (as_pctx h1 res) /\
as_pctx h1 res == S.bn_field_init (as_seq h0 n))
inline_for_extraction noextract
val bn_field_init:
#t:limb_t
-> len:BN.meta_len t
-> precomp_r2:BM.bn_precomp_r2_mod_n_st t len ->
bn_field_init_st t len
inline_for_extraction noextract
let bn_field_free_st (t:limb_t) = k:pbn_mont_ctx t ->
ST unit
(requires fun h ->
freeable h k /\
pbn_mont_ctx_inv h k)
(ensures fun h0 _ h1 ->
B.(modifies (footprint h0 k) h0 h1))
inline_for_extraction noextract
val bn_field_free: #t:limb_t -> bn_field_free_st t
inline_for_extraction noextract
let bn_to_field_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> a:lbignum t len
-> aM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
live h a /\ live h aM /\ disjoint a aM /\
B.(loc_disjoint (footprint h k) (loc_buffer (a <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc aM) h0 h1 /\
bn_v h1 aM < bn_v_n h0 k /\
as_seq h1 aM == S.bn_to_field (as_pctx h0 k) (as_seq h0 a))
inline_for_extraction noextract
val bn_to_field: #t:limb_t -> km:BM.mont t -> bn_to_field_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_from_field_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> a:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\ bn_v h aM < bn_v_n h k /\
live h a /\ live h aM /\ disjoint a aM /\
B.(loc_disjoint (footprint h k) (loc_buffer (a <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc a) h0 h1 /\
bn_v h1 a < bn_v_n h0 k /\
as_seq h1 a == S.bn_from_field (as_pctx h0 k) (as_seq h0 aM))
inline_for_extraction noextract
val bn_from_field: #t:limb_t -> km:BM.mont t -> bn_from_field_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_add_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> bM:lbignum t len
-> cM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
bn_v h bM < bn_v_n h k /\
live h aM /\ live h bM /\ live h cM /\
eq_or_disjoint aM bM /\ eq_or_disjoint aM cM /\ eq_or_disjoint bM cM /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (bM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (cM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc cM) h0 h1 /\
bn_v h1 cM < bn_v_n h0 k /\
as_seq h1 cM == S.bn_field_add (as_pctx h0 k) (as_seq h0 aM) (as_seq h0 bM))
inline_for_extraction noextract
val bn_field_add: #t:limb_t -> km:BM.mont t -> bn_field_add_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_sub_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> bM:lbignum t len
-> cM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
bn_v h bM < bn_v_n h k /\
live h aM /\ live h bM /\ live h cM /\
eq_or_disjoint aM bM /\ eq_or_disjoint aM cM /\ eq_or_disjoint bM cM /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (bM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (cM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc cM) h0 h1 /\
bn_v h1 cM < bn_v_n h0 k /\
as_seq h1 cM == S.bn_field_sub (as_pctx h0 k) (as_seq h0 aM) (as_seq h0 bM))
inline_for_extraction noextract
val bn_field_sub: #t:limb_t -> km:BM.mont t -> bn_field_sub_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_mul_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> bM:lbignum t len
-> cM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
bn_v h bM < bn_v_n h k /\
live h aM /\ live h bM /\ live h cM /\
eq_or_disjoint aM bM /\ eq_or_disjoint aM cM /\ eq_or_disjoint bM cM /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (bM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (cM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc cM) h0 h1 /\
bn_v h1 cM < bn_v_n h0 k /\
as_seq h1 cM == S.bn_field_mul (as_pctx h0 k) (as_seq h0 aM) (as_seq h0 bM))
inline_for_extraction noextract
val bn_field_mul: #t:limb_t -> km:BM.mont t -> bn_field_mul_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_sqr_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> cM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
live h aM /\ live h cM /\ eq_or_disjoint aM cM /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (cM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc cM) h0 h1 /\
bn_v h1 cM < bn_v_n h0 k /\
as_seq h1 cM == S.bn_field_sqr (as_pctx h0 k) (as_seq h0 aM))
inline_for_extraction noextract
val bn_field_sqr: #t:limb_t -> km:BM.mont t -> bn_field_sqr_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_one_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> oneM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
live h oneM /\
B.(loc_disjoint (footprint h k) (loc_buffer (oneM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc oneM) h0 h1 /\
bn_v h1 oneM < bn_v_n h0 k /\
as_seq h1 oneM == S.bn_field_one (as_pctx h0 k))
inline_for_extraction noextract
val bn_field_one: #t:limb_t -> km:BM.mont t -> bn_field_one_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_exp_consttime_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> bBits:size_t
-> b:lbignum t (blocks0 bBits (size (bits t)))
-> resM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
bn_v h b < pow2 (v bBits) /\
live h aM /\ live h b /\ live h resM /\
disjoint resM aM /\ disjoint resM b /\ disjoint aM b /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (resM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc resM) h0 h1 /\
bn_v h1 resM < bn_v_n h0 k /\
as_seq h1 resM == S.bn_field_exp_consttime (as_pctx h0 k) (as_seq h0 aM) (v bBits) (as_seq h0 b))
inline_for_extraction noextract
val bn_field_exp_consttime: #t:limb_t -> km:BM.mont t -> bn_field_exp_consttime_st t km.BM.bn.BN.len | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Euclid.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.MontArithmetic.fsti"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontArithmetic",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Euclid",
"short_module": "Euclid"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.meta_len",
"Hacl.Bignum.MontArithmetic.pbn_mont_ctx",
"Hacl.Bignum.Definitions.lbignum",
"Lib.IntTypes.size_t",
"Hacl.Bignum.Definitions.blocks0",
"Lib.IntTypes.size",
"Lib.IntTypes.bits",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.eq2",
"Hacl.Bignum.MontArithmetic.__proj__Mkbn_mont_ctx'__item__len",
"Hacl.Bignum.MontArithmetic.lb",
"Hacl.Bignum.MontArithmetic.ll",
"LowStar.Monotonic.Buffer.deref",
"Hacl.Bignum.MontArithmetic.bn_mont_ctx",
"LowStar.Buffer.trivial_preorder",
"Hacl.Bignum.MontArithmetic.pbn_mont_ctx_inv",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Bignum.Definitions.bn_v",
"Hacl.Bignum.MontArithmetic.bn_v_n",
"Prims.pow2",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Bignum.Definitions.limb",
"Lib.Buffer.disjoint",
"LowStar.Monotonic.Buffer.loc_disjoint",
"Hacl.Bignum.MontArithmetic.footprint",
"LowStar.Monotonic.Buffer.loc_buffer",
"LowStar.Buffer.buffer",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Lib.Sequence.seq",
"Prims.l_or",
"Prims.nat",
"FStar.Seq.Base.length",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.MontArithmetic.__proj__Mkbn_mont_ctx__item__len",
"Hacl.Bignum.MontArithmetic.as_pctx",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.MontArithmetic.__proj__Mkbn_mont_ctx__item__n",
"Lib.Buffer.as_seq",
"Hacl.Spec.Bignum.MontArithmetic.bn_field_exp_vartime"
] | [] | false | false | false | false | true | let bn_field_exp_vartime_st (t: limb_t) (len: BN.meta_len t) =
|
k: pbn_mont_ctx t ->
aM: lbignum t len ->
bBits: size_t ->
b: lbignum t (blocks0 bBits (size (bits t))) ->
resM: lbignum t len
-> Stack unit
(requires
fun h ->
(B.deref h k).len == len /\ pbn_mont_ctx_inv h k /\ bn_v h aM < bn_v_n h k /\
bn_v h b < pow2 (v bBits) /\ live h aM /\ live h b /\ live h resM /\ disjoint resM aM /\
disjoint resM b /\ disjoint aM b /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (resM <: buffer (limb t)))))
(ensures
fun h0 _ h1 ->
modifies (loc resM) h0 h1 /\ bn_v h1 resM < bn_v_n h0 k /\
as_seq h1 resM ==
S.bn_field_exp_vartime (as_pctx h0 k) (as_seq h0 aM) (v bBits) (as_seq h0 b)) | false |
|
Hacl.Bignum.MontArithmetic.fsti | Hacl.Bignum.MontArithmetic.bn_field_exp_consttime_st | val bn_field_exp_consttime_st : t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | let bn_field_exp_consttime_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> bBits:size_t
-> b:lbignum t (blocks0 bBits (size (bits t)))
-> resM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
bn_v h b < pow2 (v bBits) /\
live h aM /\ live h b /\ live h resM /\
disjoint resM aM /\ disjoint resM b /\ disjoint aM b /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (resM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc resM) h0 h1 /\
bn_v h1 resM < bn_v_n h0 k /\
as_seq h1 resM == S.bn_field_exp_consttime (as_pctx h0 k) (as_seq h0 aM) (v bBits) (as_seq h0 b)) | {
"file_name": "code/bignum/Hacl.Bignum.MontArithmetic.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 101,
"end_line": 368,
"start_col": 0,
"start_line": 349
} | module Hacl.Bignum.MontArithmetic
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module B = LowStar.Buffer
module HS = FStar.HyperStack
module ST = FStar.HyperStack.ST
module Euclid = FStar.Math.Euclid
module S = Hacl.Spec.Bignum.MontArithmetic
module BE = Hacl.Bignum.Exponentiation
module BN = Hacl.Bignum
module BM = Hacl.Bignum.Montgomery
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val _align_fsti : unit
inline_for_extraction noextract
let lb (t:limb_t) =
match t with
| U32 -> buffer uint32
| U64 -> buffer uint64
inline_for_extraction noextract
let ll (t:limb_t) =
match t with
| U32 -> uint32
| U64 -> uint64
inline_for_extraction
noeq
type bn_mont_ctx' (t:limb_t) (a:Type0{a == lb t}) (b:Type0{b == ll t}) = {
len: BN.meta_len t;
n: x:a{length #MUT #(limb t) x == v len};
mu: b;
r2: x:a{length #MUT #(limb t) x == v len};
}
inline_for_extraction noextract
let bn_mont_ctx (t:limb_t) = bn_mont_ctx' t (lb t) (ll t)
let bn_mont_ctx_u32 = bn_mont_ctx' U32 (lb U32) (ll U32)
let bn_mont_ctx_u64 = bn_mont_ctx' U64 (lb U64) (ll U64)
inline_for_extraction noextract
let pbn_mont_ctx (t:limb_t) = B.pointer (bn_mont_ctx t)
inline_for_extraction noextract
let pbn_mont_ctx_u32 = B.pointer bn_mont_ctx_u32
inline_for_extraction noextract
let pbn_mont_ctx_u64 = B.pointer bn_mont_ctx_u64
inline_for_extraction noextract
let as_ctx (#t:limb_t) (h:mem) (k:bn_mont_ctx t) : GTot (S.bn_mont_ctx t) = {
S.len = v k.len;
S.n = as_seq h (k.n <: lbignum t k.len);
S.mu = k.mu;
S.r2 = as_seq h (k.r2 <: lbignum t k.len);
}
inline_for_extraction noextract
let bn_mont_ctx_inv (#t:limb_t) (h:mem) (k:bn_mont_ctx t) =
let n : buffer (limb t) = k.n in
let r2 : buffer (limb t) = k.r2 in
live h n /\ live h r2 /\ disjoint n r2 /\
S.bn_mont_ctx_inv (as_ctx h k)
inline_for_extraction noextract
let bn_v_n (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) =
let k1 = B.deref h k in
let n : lbignum t k1.len = k1.n in
bn_v h n
inline_for_extraction noextract
let freeable_s (#t:limb_t) (h:mem) (k:bn_mont_ctx t) =
let n : buffer (limb t) = k.n in
let r2 : buffer (limb t) = k.r2 in
B.freeable n /\ B.freeable r2
inline_for_extraction noextract
let freeable (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) =
B.freeable k /\ freeable_s h (B.deref h k)
inline_for_extraction noextract
let footprint_s (#t:limb_t) (h:mem) (k:bn_mont_ctx t) =
let n : buffer (limb t) = k.n in
let r2 : buffer (limb t) = k.r2 in
B.(loc_union (loc_addr_of_buffer n) (loc_addr_of_buffer r2))
inline_for_extraction noextract
let footprint (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) =
B.(loc_union (loc_addr_of_buffer k) (footprint_s h (B.deref h k)))
inline_for_extraction noextract
let as_pctx (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) : GTot (S.bn_mont_ctx t) =
as_ctx h (B.deref h k)
inline_for_extraction noextract
let pbn_mont_ctx_inv (#t:limb_t) (h:mem) (k:pbn_mont_ctx t) =
B.live h k /\
B.(loc_disjoint (loc_addr_of_buffer k) (footprint_s h (B.deref h k))) /\
bn_mont_ctx_inv h (B.deref h k)
inline_for_extraction noextract
let bn_field_get_len_st (t:limb_t) = k:pbn_mont_ctx t ->
Stack (BN.meta_len t)
(requires fun h -> pbn_mont_ctx_inv h k)
(ensures fun h0 r h1 -> h0 == h1 /\
r == (B.deref h0 k).len /\
v r == S.bn_field_get_len (as_pctx h0 k))
inline_for_extraction noextract
val bn_field_get_len: #t:limb_t -> bn_field_get_len_st t
inline_for_extraction noextract
let bn_field_check_modulus_st (t:limb_t) (len:BN.meta_len t) = n:lbignum t len ->
Stack bool
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == S.bn_field_check_modulus (as_seq h0 n))
inline_for_extraction noextract
val bn_field_check_modulus: #t:limb_t -> km:BM.mont t -> bn_field_check_modulus_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_init_st (t:limb_t) (len:BN.meta_len t) =
r:HS.rid
-> n:lbignum t len ->
ST (pbn_mont_ctx t)
(requires fun h ->
S.bn_mont_ctx_pre (as_seq h n) /\
live h n /\ ST.is_eternal_region r)
(ensures fun h0 res h1 ->
B.(modifies loc_none h0 h1) /\
B.(fresh_loc (footprint h1 res) h0 h1) /\
B.(loc_includes (loc_region_only true r) (footprint h1 res)) /\
freeable h1 res /\
(B.deref h1 res).len == len /\ bn_v_n h1 res == bn_v h0 n /\
S.bn_mont_ctx_inv (as_pctx h1 res) /\
as_pctx h1 res == S.bn_field_init (as_seq h0 n))
inline_for_extraction noextract
val bn_field_init:
#t:limb_t
-> len:BN.meta_len t
-> precomp_r2:BM.bn_precomp_r2_mod_n_st t len ->
bn_field_init_st t len
inline_for_extraction noextract
let bn_field_free_st (t:limb_t) = k:pbn_mont_ctx t ->
ST unit
(requires fun h ->
freeable h k /\
pbn_mont_ctx_inv h k)
(ensures fun h0 _ h1 ->
B.(modifies (footprint h0 k) h0 h1))
inline_for_extraction noextract
val bn_field_free: #t:limb_t -> bn_field_free_st t
inline_for_extraction noextract
let bn_to_field_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> a:lbignum t len
-> aM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
live h a /\ live h aM /\ disjoint a aM /\
B.(loc_disjoint (footprint h k) (loc_buffer (a <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc aM) h0 h1 /\
bn_v h1 aM < bn_v_n h0 k /\
as_seq h1 aM == S.bn_to_field (as_pctx h0 k) (as_seq h0 a))
inline_for_extraction noextract
val bn_to_field: #t:limb_t -> km:BM.mont t -> bn_to_field_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_from_field_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> a:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\ bn_v h aM < bn_v_n h k /\
live h a /\ live h aM /\ disjoint a aM /\
B.(loc_disjoint (footprint h k) (loc_buffer (a <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc a) h0 h1 /\
bn_v h1 a < bn_v_n h0 k /\
as_seq h1 a == S.bn_from_field (as_pctx h0 k) (as_seq h0 aM))
inline_for_extraction noextract
val bn_from_field: #t:limb_t -> km:BM.mont t -> bn_from_field_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_add_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> bM:lbignum t len
-> cM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
bn_v h bM < bn_v_n h k /\
live h aM /\ live h bM /\ live h cM /\
eq_or_disjoint aM bM /\ eq_or_disjoint aM cM /\ eq_or_disjoint bM cM /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (bM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (cM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc cM) h0 h1 /\
bn_v h1 cM < bn_v_n h0 k /\
as_seq h1 cM == S.bn_field_add (as_pctx h0 k) (as_seq h0 aM) (as_seq h0 bM))
inline_for_extraction noextract
val bn_field_add: #t:limb_t -> km:BM.mont t -> bn_field_add_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_sub_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> bM:lbignum t len
-> cM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
bn_v h bM < bn_v_n h k /\
live h aM /\ live h bM /\ live h cM /\
eq_or_disjoint aM bM /\ eq_or_disjoint aM cM /\ eq_or_disjoint bM cM /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (bM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (cM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc cM) h0 h1 /\
bn_v h1 cM < bn_v_n h0 k /\
as_seq h1 cM == S.bn_field_sub (as_pctx h0 k) (as_seq h0 aM) (as_seq h0 bM))
inline_for_extraction noextract
val bn_field_sub: #t:limb_t -> km:BM.mont t -> bn_field_sub_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_mul_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> bM:lbignum t len
-> cM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
bn_v h bM < bn_v_n h k /\
live h aM /\ live h bM /\ live h cM /\
eq_or_disjoint aM bM /\ eq_or_disjoint aM cM /\ eq_or_disjoint bM cM /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (bM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (cM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc cM) h0 h1 /\
bn_v h1 cM < bn_v_n h0 k /\
as_seq h1 cM == S.bn_field_mul (as_pctx h0 k) (as_seq h0 aM) (as_seq h0 bM))
inline_for_extraction noextract
val bn_field_mul: #t:limb_t -> km:BM.mont t -> bn_field_mul_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_sqr_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> aM:lbignum t len
-> cM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
bn_v h aM < bn_v_n h k /\
live h aM /\ live h cM /\ eq_or_disjoint aM cM /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (cM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc cM) h0 h1 /\
bn_v h1 cM < bn_v_n h0 k /\
as_seq h1 cM == S.bn_field_sqr (as_pctx h0 k) (as_seq h0 aM))
inline_for_extraction noextract
val bn_field_sqr: #t:limb_t -> km:BM.mont t -> bn_field_sqr_st t km.BM.bn.BN.len
inline_for_extraction noextract
let bn_field_one_st (t:limb_t) (len:BN.meta_len t) =
k:pbn_mont_ctx t
-> oneM:lbignum t len ->
Stack unit
(requires fun h ->
(B.deref h k).len == len /\
pbn_mont_ctx_inv h k /\
live h oneM /\
B.(loc_disjoint (footprint h k) (loc_buffer (oneM <: buffer (limb t)))))
(ensures fun h0 _ h1 -> modifies (loc oneM) h0 h1 /\
bn_v h1 oneM < bn_v_n h0 k /\
as_seq h1 oneM == S.bn_field_one (as_pctx h0 k))
inline_for_extraction noextract
val bn_field_one: #t:limb_t -> km:BM.mont t -> bn_field_one_st t km.BM.bn.BN.len | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Euclid.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.MontArithmetic.fsti"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontArithmetic",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Euclid",
"short_module": "Euclid"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.meta_len",
"Hacl.Bignum.MontArithmetic.pbn_mont_ctx",
"Hacl.Bignum.Definitions.lbignum",
"Lib.IntTypes.size_t",
"Hacl.Bignum.Definitions.blocks0",
"Lib.IntTypes.size",
"Lib.IntTypes.bits",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.eq2",
"Hacl.Bignum.MontArithmetic.__proj__Mkbn_mont_ctx'__item__len",
"Hacl.Bignum.MontArithmetic.lb",
"Hacl.Bignum.MontArithmetic.ll",
"LowStar.Monotonic.Buffer.deref",
"Hacl.Bignum.MontArithmetic.bn_mont_ctx",
"LowStar.Buffer.trivial_preorder",
"Hacl.Bignum.MontArithmetic.pbn_mont_ctx_inv",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Bignum.Definitions.bn_v",
"Hacl.Bignum.MontArithmetic.bn_v_n",
"Prims.pow2",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Bignum.Definitions.limb",
"Lib.Buffer.disjoint",
"LowStar.Monotonic.Buffer.loc_disjoint",
"Hacl.Bignum.MontArithmetic.footprint",
"LowStar.Monotonic.Buffer.loc_buffer",
"LowStar.Buffer.buffer",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Lib.Sequence.seq",
"Prims.l_or",
"Prims.nat",
"FStar.Seq.Base.length",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.MontArithmetic.__proj__Mkbn_mont_ctx__item__len",
"Hacl.Bignum.MontArithmetic.as_pctx",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.MontArithmetic.__proj__Mkbn_mont_ctx__item__n",
"Lib.Buffer.as_seq",
"Hacl.Spec.Bignum.MontArithmetic.bn_field_exp_consttime"
] | [] | false | false | false | false | true | let bn_field_exp_consttime_st (t: limb_t) (len: BN.meta_len t) =
|
k: pbn_mont_ctx t ->
aM: lbignum t len ->
bBits: size_t ->
b: lbignum t (blocks0 bBits (size (bits t))) ->
resM: lbignum t len
-> Stack unit
(requires
fun h ->
(B.deref h k).len == len /\ pbn_mont_ctx_inv h k /\ bn_v h aM < bn_v_n h k /\
bn_v h b < pow2 (v bBits) /\ live h aM /\ live h b /\ live h resM /\ disjoint resM aM /\
disjoint resM b /\ disjoint aM b /\
B.(loc_disjoint (footprint h k) (loc_buffer (aM <: buffer (limb t)))) /\
B.(loc_disjoint (footprint h k) (loc_buffer (resM <: buffer (limb t)))))
(ensures
fun h0 _ h1 ->
modifies (loc resM) h0 h1 /\ bn_v h1 resM < bn_v_n h0 k /\
as_seq h1 resM ==
S.bn_field_exp_consttime (as_pctx h0 k) (as_seq h0 aM) (v bBits) (as_seq h0 b)) | false |
|
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.from_mont_sub_lemma | val from_mont_sub_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = (aM - bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == (a - b) % n)) | val from_mont_sub_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = (aM - bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == (a - b) % n)) | let from_mont_sub_lemma pbits rLen n mu aM bM =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = (aM - bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
from_mont_lemma pbits rLen n mu cM;
assert (c == cM * d % n);
calc (==) { //c
cM * d % n;
(==) { }
(aM - bM) % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM - bM) d n }
(aM - bM) * d % n;
(==) { Math.Lemmas.distributivity_sub_left aM bM d }
(aM * d - bM * d) % n;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (aM * d) (- bM * d) n }
(aM * d % n - bM * d) % n;
(==) { Math.Lemmas.lemma_mod_sub_distr (aM * d % n) (bM * d) n }
(aM * d % n - bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 751,
"start_col": 0,
"start_line": 724
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n))
let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n
val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n))
let mont_mul_lemma pbits rLen n mu a b =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b)
/// Lemma (to_mont rLen n mu a == a * r % n)
val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma
(a * (b % n) * c % n == a * b * c % n)
let lemma_mod_mul_distr3 a b c n =
calc (==) {
a * (b % n) * c % n;
(==) { }
(b % n) * a * c % n;
(==) { Math.Lemmas.paren_mul_right (b % n) a c }
(b % n) * (a * c) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l b (a * c) n }
b * (a * c) % n;
(==) { Math.Lemmas.paren_mul_right b a c }
a * b * c % n;
}
val mult_lt_lemma: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d)
let mult_lt_lemma a b c d = ()
val to_mont_eval_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
a * r2 * d % n == a * r % n))
let to_mont_eval_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let c = a * r2 in
calc (==) {
c * d % n;
(==) { }
a * r2 * d % n;
(==) { Math.Lemmas.paren_mul_right 2 pbits rLen;
Math.Lemmas.pow2_plus (pbits * rLen) (pbits * rLen) }
a * (r * r % n) * d % n;
(==) { lemma_mod_mul_distr3 a (r * r) d n }
a * (r * r) * d % n;
(==) { Math.Lemmas.paren_mul_right a r r }
a * r * r * d % n;
(==) { Math.Lemmas.paren_mul_right (a * r) r d }
a * r * (r * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (a * r) (r * d) n }
a * r * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a * r % n;
};
assert (c * d % n == a * r % n)
val to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < pow2 (pbits * rLen))
(ensures to_mont pbits rLen n mu a == a * pow2 (pbits * rLen) % n)
let to_mont_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let c = a * r2 in
let aM = to_mont pbits rLen n mu a in
assert (aM == mont_reduction pbits rLen n mu c);
mult_lt_lemma a r2 r n;
assert (a * r2 < r * n);
mont_reduction_lemma pbits rLen n mu c;
assert (aM == c * d % n);
to_mont_eval_lemma pbits rLen n mu a;
assert (aM == a * r % n)
/// Lemma (from_mont rLen n mu aM == aM * d % n)
val from_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ aM < pow2 (pbits * rLen))
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
from_mont pbits rLen n mu aM == aM * d % n))
let from_mont_lemma pbits rLen n mu aM =
mont_reduction_lemma pbits rLen n mu aM
/// Lemma (mont_one pbits rLen n mu == 1 * r % n)
val mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures mont_one pbits rLen n mu == 1 * pow2 (pbits * rLen) % n)
let mont_one_lemma pbits rLen n mu =
to_mont_lemma pbits rLen n mu 1
/// Properties of Montgomery arithmetic
// from_mont (to_mont a) = a % n
val lemma_mont_id: n:pos -> r:pos -> d:int{r * d % n == 1} -> a:nat ->
Lemma (a * r % n * d % n == a % n)
let lemma_mont_id n r d a =
calc (==) {
a * r % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * r) d n }
a * r * d % n;
(==) { Math.Lemmas.paren_mul_right a r d; Math.Lemmas.lemma_mod_mul_distr_r a (r * d) n }
a * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a % n;
}
// to_mont (mont_reduction a) = a % n
val lemma_mont_id1: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (a * d % n * r % n == a % n)
let lemma_mont_id1 n r d a =
calc (==) {
((a * d % n) * r) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * d) r n }
((a * d) * r) % n;
(==) { Math.Lemmas.paren_mul_right a d r }
(a * (d * r)) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r a (d * r) n }
(a * (d * r % n)) % n;
(==) { assert (r * d % n = 1) }
a % n;
};
assert (a * d % n * r % n == a % n)
// one_M * a = a
val lemma_mont_mul_one: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (let r0 = 1 * r % n in let r1 = a * r % n in r0 * r1 * d % n == r1 % n)
let lemma_mont_mul_one n r d a =
let r0 = 1 * r % n in
let r1 = a * r % n in
calc (==) {
r1 * r0 * d % n;
(==) { Math.Lemmas.paren_mul_right r1 r0 d; Math.Lemmas.lemma_mod_mul_distr_r r1 (r0 * d) n }
r1 * (r0 * d % n) % n;
(==) { lemma_mont_id n r d 1 }
r1 * (1 % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r r1 1 n }
r1 % n;
}
val from_mont_add_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = (aM + bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == (a + b) % n))
let from_mont_add_lemma pbits rLen n mu aM bM =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = (aM + bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
from_mont_lemma pbits rLen n mu cM;
assert (c == cM * d % n);
calc (==) { //c
cM * d % n;
(==) { }
(aM + bM) % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM + bM) d n }
(aM + bM) * d % n;
(==) { Math.Lemmas.distributivity_add_left aM bM d }
(aM * d + bM * d) % n;
(==) { Math.Lemmas.modulo_distributivity (aM * d) (bM * d) n }
(aM * d % n + bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM
val from_mont_sub_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = (aM - bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == (a - b) % n)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
pbits: Prims.pos ->
rLen: Prims.pos ->
n: Prims.pos ->
mu: Prims.nat ->
aM: Prims.nat ->
bM: Prims.nat
-> FStar.Pervasives.Lemma
(requires Hacl.Spec.Montgomery.Lemmas.mont_pre pbits rLen n mu /\ aM < n /\ bM < n)
(ensures
(let cM = (aM - bM) % n in
let c = Hacl.Spec.Montgomery.Lemmas.from_mont pbits rLen n mu cM in
let a = Hacl.Spec.Montgomery.Lemmas.from_mont pbits rLen n mu aM in
let b = Hacl.Spec.Montgomery.Lemmas.from_mont pbits rLen n mu bM in
c == (a - b) % n)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.int",
"Hacl.Spec.Montgomery.Lemmas.from_mont_lemma",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.lemma_mod_mul_distr_l",
"FStar.Math.Lemmas.distributivity_sub_left",
"FStar.Math.Lemmas.lemma_mod_plus_distr_l",
"Prims.op_Minus",
"FStar.Math.Lemmas.lemma_mod_sub_distr",
"Prims._assert",
"Hacl.Spec.Montgomery.Lemmas.from_mont",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd",
"Prims.pow2"
] | [] | false | false | true | false | false | let from_mont_sub_lemma pbits rLen n mu aM bM =
| let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = (aM - bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
from_mont_lemma pbits rLen n mu cM;
assert (c == cM * d % n);
calc ( == ) {
cM * d % n;
( == ) { () }
((aM - bM) % n) * d % n;
( == ) { Math.Lemmas.lemma_mod_mul_distr_l (aM - bM) d n }
(aM - bM) * d % n;
( == ) { Math.Lemmas.distributivity_sub_left aM bM d }
(aM * d - bM * d) % n;
( == ) { Math.Lemmas.lemma_mod_plus_distr_l (aM * d) (- bM * d) n }
(aM * d % n - bM * d) % n;
( == ) { Math.Lemmas.lemma_mod_sub_distr (aM * d % n) (bM * d) n }
(aM * d % n - bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.from_mont_add_lemma | val from_mont_add_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = (aM + bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == (a + b) % n)) | val from_mont_add_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = (aM + bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == (a + b) % n)) | let from_mont_add_lemma pbits rLen n mu aM bM =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = (aM + bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
from_mont_lemma pbits rLen n mu cM;
assert (c == cM * d % n);
calc (==) { //c
cM * d % n;
(==) { }
(aM + bM) % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM + bM) d n }
(aM + bM) * d % n;
(==) { Math.Lemmas.distributivity_add_left aM bM d }
(aM * d + bM * d) % n;
(==) { Math.Lemmas.modulo_distributivity (aM * d) (bM * d) n }
(aM * d % n + bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 710,
"start_col": 0,
"start_line": 685
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n))
let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n
val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n))
let mont_mul_lemma pbits rLen n mu a b =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b)
/// Lemma (to_mont rLen n mu a == a * r % n)
val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma
(a * (b % n) * c % n == a * b * c % n)
let lemma_mod_mul_distr3 a b c n =
calc (==) {
a * (b % n) * c % n;
(==) { }
(b % n) * a * c % n;
(==) { Math.Lemmas.paren_mul_right (b % n) a c }
(b % n) * (a * c) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l b (a * c) n }
b * (a * c) % n;
(==) { Math.Lemmas.paren_mul_right b a c }
a * b * c % n;
}
val mult_lt_lemma: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d)
let mult_lt_lemma a b c d = ()
val to_mont_eval_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
a * r2 * d % n == a * r % n))
let to_mont_eval_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let c = a * r2 in
calc (==) {
c * d % n;
(==) { }
a * r2 * d % n;
(==) { Math.Lemmas.paren_mul_right 2 pbits rLen;
Math.Lemmas.pow2_plus (pbits * rLen) (pbits * rLen) }
a * (r * r % n) * d % n;
(==) { lemma_mod_mul_distr3 a (r * r) d n }
a * (r * r) * d % n;
(==) { Math.Lemmas.paren_mul_right a r r }
a * r * r * d % n;
(==) { Math.Lemmas.paren_mul_right (a * r) r d }
a * r * (r * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (a * r) (r * d) n }
a * r * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a * r % n;
};
assert (c * d % n == a * r % n)
val to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < pow2 (pbits * rLen))
(ensures to_mont pbits rLen n mu a == a * pow2 (pbits * rLen) % n)
let to_mont_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let c = a * r2 in
let aM = to_mont pbits rLen n mu a in
assert (aM == mont_reduction pbits rLen n mu c);
mult_lt_lemma a r2 r n;
assert (a * r2 < r * n);
mont_reduction_lemma pbits rLen n mu c;
assert (aM == c * d % n);
to_mont_eval_lemma pbits rLen n mu a;
assert (aM == a * r % n)
/// Lemma (from_mont rLen n mu aM == aM * d % n)
val from_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ aM < pow2 (pbits * rLen))
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
from_mont pbits rLen n mu aM == aM * d % n))
let from_mont_lemma pbits rLen n mu aM =
mont_reduction_lemma pbits rLen n mu aM
/// Lemma (mont_one pbits rLen n mu == 1 * r % n)
val mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures mont_one pbits rLen n mu == 1 * pow2 (pbits * rLen) % n)
let mont_one_lemma pbits rLen n mu =
to_mont_lemma pbits rLen n mu 1
/// Properties of Montgomery arithmetic
// from_mont (to_mont a) = a % n
val lemma_mont_id: n:pos -> r:pos -> d:int{r * d % n == 1} -> a:nat ->
Lemma (a * r % n * d % n == a % n)
let lemma_mont_id n r d a =
calc (==) {
a * r % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * r) d n }
a * r * d % n;
(==) { Math.Lemmas.paren_mul_right a r d; Math.Lemmas.lemma_mod_mul_distr_r a (r * d) n }
a * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a % n;
}
// to_mont (mont_reduction a) = a % n
val lemma_mont_id1: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (a * d % n * r % n == a % n)
let lemma_mont_id1 n r d a =
calc (==) {
((a * d % n) * r) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * d) r n }
((a * d) * r) % n;
(==) { Math.Lemmas.paren_mul_right a d r }
(a * (d * r)) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r a (d * r) n }
(a * (d * r % n)) % n;
(==) { assert (r * d % n = 1) }
a % n;
};
assert (a * d % n * r % n == a % n)
// one_M * a = a
val lemma_mont_mul_one: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (let r0 = 1 * r % n in let r1 = a * r % n in r0 * r1 * d % n == r1 % n)
let lemma_mont_mul_one n r d a =
let r0 = 1 * r % n in
let r1 = a * r % n in
calc (==) {
r1 * r0 * d % n;
(==) { Math.Lemmas.paren_mul_right r1 r0 d; Math.Lemmas.lemma_mod_mul_distr_r r1 (r0 * d) n }
r1 * (r0 * d % n) % n;
(==) { lemma_mont_id n r d 1 }
r1 * (1 % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r r1 1 n }
r1 % n;
}
val from_mont_add_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = (aM + bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == (a + b) % n)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
pbits: Prims.pos ->
rLen: Prims.pos ->
n: Prims.pos ->
mu: Prims.nat ->
aM: Prims.nat ->
bM: Prims.nat
-> FStar.Pervasives.Lemma
(requires Hacl.Spec.Montgomery.Lemmas.mont_pre pbits rLen n mu /\ aM < n /\ bM < n)
(ensures
(let cM = (aM + bM) % n in
let c = Hacl.Spec.Montgomery.Lemmas.from_mont pbits rLen n mu cM in
let a = Hacl.Spec.Montgomery.Lemmas.from_mont pbits rLen n mu aM in
let b = Hacl.Spec.Montgomery.Lemmas.from_mont pbits rLen n mu bM in
c == (a + b) % n)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.int",
"Hacl.Spec.Montgomery.Lemmas.from_mont_lemma",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Prims.op_Addition",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.lemma_mod_mul_distr_l",
"FStar.Math.Lemmas.distributivity_add_left",
"FStar.Math.Lemmas.modulo_distributivity",
"Prims._assert",
"Hacl.Spec.Montgomery.Lemmas.from_mont",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd",
"Prims.pow2"
] | [] | false | false | true | false | false | let from_mont_add_lemma pbits rLen n mu aM bM =
| let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = (aM + bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
from_mont_lemma pbits rLen n mu cM;
assert (c == cM * d % n);
calc ( == ) {
cM * d % n;
( == ) { () }
((aM + bM) % n) * d % n;
( == ) { Math.Lemmas.lemma_mod_mul_distr_l (aM + bM) d n }
(aM + bM) * d % n;
( == ) { Math.Lemmas.distributivity_add_left aM bM d }
(aM * d + bM * d) % n;
( == ) { Math.Lemmas.modulo_distributivity (aM * d) (bM * d) n }
(aM * d % n + bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.mont_reduction_loop_div_r_eval_lemma | val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n)) | val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n)) | let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n) | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 451,
"start_col": 0,
"start_line": 429
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | pbits: Prims.pos -> rLen: Prims.nat -> n: Prims.pos -> d: Prims.int -> mu: Prims.nat -> c: Prims.nat
-> FStar.Pervasives.Lemma
(requires
(let r = Prims.pow2 (pbits * rLen) in
(1 + n * mu) % Prims.pow2 pbits == 0 /\ r * d % n == 1))
(ensures
(let res = Hacl.Spec.Montgomery.Lemmas.mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.int",
"Prims._assert",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.op_Division",
"FStar.Mul.op_Star",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"FStar.Math.Lemmas.paren_mul_right",
"FStar.Math.Lemmas.div_exact_r",
"FStar.Math.Lemmas.lemma_mod_mul_distr_l",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Prims.op_Subtraction",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_loop_lemma",
"Lib.LoopCombinators.repeati",
"Hacl.Spec.Montgomery.Lemmas.mont_reduction_f",
"Prims.pow2"
] | [] | false | false | true | false | false | let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
| let r = pow2 (pbits * rLen) in
let res:nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc ( == ) {
res / r % n;
( == ) { assert (r * d % n == 1) }
(res / r) * (r * d % n) % n;
( == ) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
(res / r) * (r * d) % n;
( == ) { Math.Lemmas.paren_mul_right (res / r) r d }
((res / r) * r) * d % n;
( == ) { Math.Lemmas.div_exact_r res r }
res * d % n;
( == ) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
(res % n) * d % n;
( == ) { assert (res % n == c % n) }
(c % n) * d % n;
( == ) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n) | false |
Vale.AES.GCTR.fsti | Vale.AES.GCTR.gctr_partial_def | val gctr_partial_def
(alg: algorithm)
(bound: nat)
(plain cipher: seq quad32)
(key: seq nat32)
(icb: quad32)
: prop0 | val gctr_partial_def
(alg: algorithm)
(bound: nat)
(plain cipher: seq quad32)
(key: seq nat32)
(icb: quad32)
: prop0 | let gctr_partial_def (alg:algorithm) (bound:nat) (plain cipher:seq quad32) (key:seq nat32) (icb:quad32) : prop0 =
is_aes_key_LE alg key /\
( let bound = min bound (min (length plain) (length cipher)) in
forall j . {:pattern (index cipher j)} 0 <= j /\ j < bound ==>
index cipher j == quad32_xor (index plain j) (aes_encrypt_BE alg key (inc32 icb j))) | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 90,
"end_line": 96,
"start_col": 0,
"start_line": 92
} | module Vale.AES.GCTR
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
let make_gctr_plain_LE (p:seq nat8) : seq nat8 =
if length p < pow2_32 then p else empty
let inc32lite (cb:quad32) (i:int) : quad32 =
if 0 <= i && i < pow2_32 then
let sum = cb.lo0 + i in
let lo0 = if sum >= pow2_32 then sum - pow2_32 else sum in
Mkfour lo0 cb.lo1 cb.hi2 cb.hi3
else
Mkfour 42 42 42 42
let empty_seq_quad32 : seq quad32 = empty
val lemma_counter_init (x:quad32) (low64 low8:nat64) : Lemma
(requires low64 == lo64 x /\
low8 == iand64 low64 0xff)
(ensures low8 == x.lo0 % 256)
let partial_seq_agreement (x y:seq quad32) (lo hi:nat) =
lo <= hi /\ hi <= length x /\ hi <= length y /\
(forall i . {:pattern (index x i) \/ (index y i)} lo <= i /\ i < hi ==> index x i == index y i)
(*
let lemma_partial_seq_agreement_subset (x y:seq quad32) (lo hi hi':nat) : Lemma
(requires lo <= hi /\ hi <= hi' /\ hi' <= length x /\ hi' <= length y /\
partial_seq_agreement x y lo hi')
(ensures partial_seq_agreement x y lo hi)
=
()
*)
(*
let lemma_partial_seq_agreement_step (x y z:seq quad32) (lo mid hi:nat) : Lemma
(requires partial_seq_agreement x y lo hi /\
length z >= hi /\
lo <= mid /\ mid < hi /\
(forall i . 0 <= i /\ i < length z /\ (i < lo || i > mid) ==>
index y i == index z i))
(ensures partial_seq_agreement x z (mid+1) hi)
=
()
*)
val gctr_encrypt_block_offset (icb_BE:quad32) (plain_LE:quad32) (alg:algorithm) (key:seq nat32) (i:int) : Lemma
(requires is_aes_key_LE alg key)
(ensures
gctr_encrypt_block icb_BE plain_LE alg key i ==
gctr_encrypt_block (inc32 icb_BE i) plain_LE alg key 0
)
val gctr_encrypt_empty (icb_BE:quad32) (plain_LE cipher_LE:seq quad32) (alg:algorithm) (key:seq nat32) : Lemma
(requires is_aes_key_LE alg key)
(ensures (
let plain = slice (le_seq_quad32_to_bytes plain_LE) 0 0 in
let cipher = slice (le_seq_quad32_to_bytes cipher_LE) 0 0 in
cipher = gctr_encrypt_LE icb_BE (make_gctr_plain_LE plain) alg key
))
let aes_encrypt_BE (alg:algorithm) (key:seq nat32) (p_BE:quad32) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let p_LE = reverse_bytes_quad32 p_BE in
aes_encrypt_LE alg key p_LE
let gctr_registers_def (r0 r1 r2 r3 r4 r5:quad32) (s:seq quad32) (alg:algorithm) (key:seq nat32) (ctr_BE:quad32) (i:int) : prop0 =
0 <= i /\ i*6 + 5 < length s /\
is_aes_key_LE alg key /\
r0 = quad32_xor (index s (i*6 + 0)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 0))) /\
r1 = quad32_xor (index s (i*6 + 1)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 1))) /\
r2 = quad32_xor (index s (i*6 + 2)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 2))) /\
r3 = quad32_xor (index s (i*6 + 3)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 3))) /\
r4 = quad32_xor (index s (i*6 + 4)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 4))) /\
r5 = quad32_xor (index s (i*6 + 5)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 5)))
[@"opaque_to_smt"] let gctr_registers = opaque_make gctr_registers_def
irreducible let gctr_registers_reveal = opaque_revealer (`%gctr_registers) gctr_registers gctr_registers_def | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.GCTR_s.fst.checked",
"Vale.AES.GCM_helpers.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
alg: Vale.AES.AES_common_s.algorithm ->
bound: Prims.nat ->
plain: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
cipher: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
key: FStar.Seq.Base.seq Vale.Def.Types_s.nat32 ->
icb: Vale.Def.Types_s.quad32
-> Vale.Def.Prop_s.prop0 | Prims.Tot | [
"total"
] | [] | [
"Vale.AES.AES_common_s.algorithm",
"Prims.nat",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.nat32",
"Prims.l_and",
"Vale.AES.AES_s.is_aes_key_LE",
"Prims.l_Forall",
"Prims.int",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.l_imp",
"Prims.op_LessThanOrEqual",
"Prims.eq2",
"FStar.Seq.Base.index",
"Vale.Def.Types_s.quad32_xor",
"Vale.AES.GCTR.aes_encrypt_BE",
"Vale.AES.GCTR_s.inc32",
"Prims.min",
"Vale.Def.Prop_s.prop0"
] | [] | false | false | false | true | false | let gctr_partial_def
(alg: algorithm)
(bound: nat)
(plain cipher: seq quad32)
(key: seq nat32)
(icb: quad32)
: prop0 =
| is_aes_key_LE alg key /\
(let bound = min bound (min (length plain) (length cipher)) in
forall j. {:pattern (index cipher j)}
0 <= j /\ j < bound ==>
index cipher j == quad32_xor (index plain j) (aes_encrypt_BE alg key (inc32 icb j))) | false |
Hacl.Impl.P256.Verify.fst | Hacl.Impl.P256.Verify.load_signature | val load_signature (r_q s_q:felem) (sign_r sign_s:lbytes 32ul) : Stack bool
(requires fun h ->
live h sign_r /\ live h sign_s /\ live h r_q /\ live h s_q /\
disjoint r_q s_q /\ disjoint r_q sign_r /\ disjoint r_q sign_s /\
disjoint s_q sign_r /\ disjoint s_q sign_s)
(ensures fun h0 res h1 -> modifies (loc r_q |+| loc s_q) h0 h1 /\
(let r_q_nat = BSeq.nat_from_bytes_be (as_seq h0 sign_r) in
let s_q_nat = BSeq.nat_from_bytes_be (as_seq h0 sign_s) in
as_nat h1 r_q = r_q_nat /\ as_nat h1 s_q = s_q_nat /\
res == (0 < r_q_nat && r_q_nat < S.order && 0 < s_q_nat && s_q_nat < S.order))) | val load_signature (r_q s_q:felem) (sign_r sign_s:lbytes 32ul) : Stack bool
(requires fun h ->
live h sign_r /\ live h sign_s /\ live h r_q /\ live h s_q /\
disjoint r_q s_q /\ disjoint r_q sign_r /\ disjoint r_q sign_s /\
disjoint s_q sign_r /\ disjoint s_q sign_s)
(ensures fun h0 res h1 -> modifies (loc r_q |+| loc s_q) h0 h1 /\
(let r_q_nat = BSeq.nat_from_bytes_be (as_seq h0 sign_r) in
let s_q_nat = BSeq.nat_from_bytes_be (as_seq h0 sign_s) in
as_nat h1 r_q = r_q_nat /\ as_nat h1 s_q = s_q_nat /\
res == (0 < r_q_nat && r_q_nat < S.order && 0 < s_q_nat && s_q_nat < S.order))) | let load_signature r_q s_q sign_r sign_s =
bn_from_bytes_be4 r_q sign_r;
bn_from_bytes_be4 s_q sign_s;
let is_r_valid = bn_is_lt_order_and_gt_zero_mask4 r_q in
let is_s_valid = bn_is_lt_order_and_gt_zero_mask4 s_q in
Hacl.Bignum.Base.unsafe_bool_of_limb is_r_valid &&
Hacl.Bignum.Base.unsafe_bool_of_limb is_s_valid | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Verify.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 49,
"end_line": 153,
"start_col": 0,
"start_line": 147
} | module Hacl.Impl.P256.Verify
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Point
open Hacl.Impl.P256.Scalar
open Hacl.Impl.P256.PointMul
module BSeq = Lib.ByteSequence
module S = Spec.P256
module SL = Spec.P256.Lemmas
module SM = Hacl.Spec.P256.Montgomery
module QI = Hacl.Impl.P256.Qinv
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let lbytes len = lbuffer uint8 len
val qmul_mont: sinv:felem -> b:felem -> res:felem -> Stack unit
(requires fun h ->
live h sinv /\ live h b /\ live h res /\
disjoint sinv res /\ disjoint b res /\
as_nat h sinv < S.order /\ as_nat h b < S.order)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_nat h1 res < S.order /\
as_nat h1 res = (as_nat h0 sinv * SM.from_qmont (as_nat h0 b) * SM.qmont_R_inv) % S.order)
[@CInline]
let qmul_mont sinv b res =
let h0 = ST.get () in
push_frame ();
let tmp = create_felem () in
from_qmont tmp b;
let h1 = ST.get () in
assert (as_nat h1 tmp == SM.from_qmont (as_nat h0 b));
qmul res sinv tmp;
let h2 = ST.get () in
assert (as_nat h2 res = (as_nat h1 sinv * as_nat h1 tmp * SM.qmont_R_inv) % S.order);
pop_frame ()
inline_for_extraction noextract
val ecdsa_verification_get_u12: u1:felem -> u2:felem -> r:felem -> s:felem -> z:felem -> Stack unit
(requires fun h ->
live h r /\ live h s /\ live h z /\ live h u1 /\ live h u2 /\
disjoint u1 u2 /\ disjoint u1 z /\ disjoint u1 r /\ disjoint u1 s /\
disjoint u2 z /\ disjoint u2 r /\ disjoint u2 s /\
as_nat h s < S.order /\ as_nat h z < S.order /\ as_nat h r < S.order)
(ensures fun h0 _ h1 -> modifies (loc u1 |+| loc u2) h0 h1 /\
(let sinv = S.qinv (as_nat h0 s) in
as_nat h1 u1 == sinv * as_nat h0 z % S.order /\
as_nat h1 u2 == sinv * as_nat h0 r % S.order))
let ecdsa_verification_get_u12 u1 u2 r s z =
push_frame ();
let h0 = ST.get () in
let sinv = create_felem () in
QI.qinv sinv s;
let h1 = ST.get () in
assert (qmont_as_nat h1 sinv == S.qinv (qmont_as_nat h0 s));
//assert (as_nat h2 sinv * SM.qmont_R_inv % S.order ==
//S.qinv (as_nat h1 sinv * SM.qmont_R_inv % S.order));
SM.qmont_inv_mul_lemma (as_nat h0 s) (as_nat h1 sinv) (as_nat h0 z);
SM.qmont_inv_mul_lemma (as_nat h0 s) (as_nat h1 sinv) (as_nat h0 r);
qmul_mont sinv z u1;
qmul_mont sinv r u2;
pop_frame ()
inline_for_extraction noextract
val ecdsa_verify_finv: p:point -> r:felem -> Stack bool
(requires fun h ->
live h p /\ live h r /\ disjoint p r /\
point_inv h p /\ 0 < as_nat h r /\ as_nat h r < S.order)
//not (S.is_point_at_inf (from_mont_point (as_point_nat h p))))
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
(let (_X, _Y, _Z) = from_mont_point (as_point_nat h0 p) in
b <==> (S.fmul _X (S.finv _Z) % S.order = as_nat h0 r)))
let ecdsa_verify_finv p r_q =
push_frame ();
let x = create_felem () in
to_aff_point_x x p;
qmod_short x x;
let res = bn_is_eq_vartime4 x r_q in
pop_frame ();
res
inline_for_extraction noextract
val ecdsa_verification_cmpr: r:felem -> pk:point -> u1:felem -> u2:felem -> Stack bool
(requires fun h ->
live h r /\ live h pk /\ live h u1 /\ live h u2 /\
disjoint r u1 /\ disjoint r u2 /\ disjoint r pk /\
disjoint pk u1 /\ disjoint pk u2 /\
point_inv h pk /\ as_nat h u1 < S.order /\ as_nat h u2 < S.order /\
0 < as_nat h r /\ as_nat h r < S.order)
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
(let _X, _Y, _Z = S.point_mul_double_g (as_nat h0 u1) (as_nat h0 u2)
(from_mont_point (as_point_nat h0 pk)) in
b <==> (if S.is_point_at_inf (_X, _Y, _Z) then false
else S.fmul _X (S.finv _Z) % S.order = as_nat h0 r)))
let ecdsa_verification_cmpr r pk u1 u2 =
push_frame ();
let res = create_point () in
let h0 = ST.get () in
point_mul_double_g res u1 u2 pk;
let h1 = ST.get () in
assert (S.to_aff_point (from_mont_point (as_point_nat h1 res)) ==
S.to_aff_point (S.point_mul_double_g (as_nat h0 u1) (as_nat h0 u2)
(from_mont_point (as_point_nat h0 pk))));
SL.lemma_aff_is_point_at_inf (from_mont_point (as_point_nat h1 res));
SL.lemma_aff_is_point_at_inf
(S.point_mul_double_g (as_nat h0 u1) (as_nat h0 u2) (from_mont_point (as_point_nat h0 pk)));
let b =
if is_point_at_inf_vartime res then false
else ecdsa_verify_finv res r in
pop_frame ();
b
inline_for_extraction noextract
val load_signature (r_q s_q:felem) (sign_r sign_s:lbytes 32ul) : Stack bool
(requires fun h ->
live h sign_r /\ live h sign_s /\ live h r_q /\ live h s_q /\
disjoint r_q s_q /\ disjoint r_q sign_r /\ disjoint r_q sign_s /\
disjoint s_q sign_r /\ disjoint s_q sign_s)
(ensures fun h0 res h1 -> modifies (loc r_q |+| loc s_q) h0 h1 /\
(let r_q_nat = BSeq.nat_from_bytes_be (as_seq h0 sign_r) in
let s_q_nat = BSeq.nat_from_bytes_be (as_seq h0 sign_s) in
as_nat h1 r_q = r_q_nat /\ as_nat h1 s_q = s_q_nat /\
res == (0 < r_q_nat && r_q_nat < S.order && 0 < s_q_nat && s_q_nat < S.order))) | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Impl.P256.Scalar.fsti.checked",
"Hacl.Impl.P256.Qinv.fsti.checked",
"Hacl.Impl.P256.PointMul.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.P256.Verify.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Impl.P256.Qinv",
"short_module": "QI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.PointMul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r_q: Hacl.Impl.P256.Bignum.felem ->
s_q: Hacl.Impl.P256.Bignum.felem ->
sign_r: Hacl.Impl.P256.Verify.lbytes 32ul ->
sign_s: Hacl.Impl.P256.Verify.lbytes 32ul
-> FStar.HyperStack.ST.Stack Prims.bool | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"Hacl.Impl.P256.Verify.lbytes",
"FStar.UInt32.__uint_to_t",
"Prims.op_AmpAmp",
"Hacl.Spec.Bignum.Base.unsafe_bool_of_limb",
"Lib.IntTypes.U64",
"Prims.bool",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Hacl.Impl.P256.Scalar.bn_is_lt_order_and_gt_zero_mask4",
"Lib.IntTypes.uint64",
"Prims.unit",
"Hacl.Impl.P256.Bignum.bn_from_bytes_be4"
] | [] | false | true | false | false | false | let load_signature r_q s_q sign_r sign_s =
| bn_from_bytes_be4 r_q sign_r;
bn_from_bytes_be4 s_q sign_s;
let is_r_valid = bn_is_lt_order_and_gt_zero_mask4 r_q in
let is_s_valid = bn_is_lt_order_and_gt_zero_mask4 s_q in
Hacl.Bignum.Base.unsafe_bool_of_limb is_r_valid && Hacl.Bignum.Base.unsafe_bool_of_limb is_s_valid | false |
Vale.AES.GCTR.fsti | Vale.AES.GCTR.partial_seq_agreement | val partial_seq_agreement : x: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
y: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
lo: Prims.nat ->
hi: Prims.nat
-> Prims.logical | let partial_seq_agreement (x y:seq quad32) (lo hi:nat) =
lo <= hi /\ hi <= length x /\ hi <= length y /\
(forall i . {:pattern (index x i) \/ (index y i)} lo <= i /\ i < hi ==> index x i == index y i) | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 97,
"end_line": 36,
"start_col": 0,
"start_line": 34
} | module Vale.AES.GCTR
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
let make_gctr_plain_LE (p:seq nat8) : seq nat8 =
if length p < pow2_32 then p else empty
let inc32lite (cb:quad32) (i:int) : quad32 =
if 0 <= i && i < pow2_32 then
let sum = cb.lo0 + i in
let lo0 = if sum >= pow2_32 then sum - pow2_32 else sum in
Mkfour lo0 cb.lo1 cb.hi2 cb.hi3
else
Mkfour 42 42 42 42
let empty_seq_quad32 : seq quad32 = empty
val lemma_counter_init (x:quad32) (low64 low8:nat64) : Lemma
(requires low64 == lo64 x /\
low8 == iand64 low64 0xff)
(ensures low8 == x.lo0 % 256) | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.GCTR_s.fst.checked",
"Vale.AES.GCM_helpers.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
x: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
y: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
lo: Prims.nat ->
hi: Prims.nat
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.l_Forall",
"Prims.int",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThan",
"Prims.l_imp",
"Prims.eq2",
"FStar.Seq.Base.index",
"Prims.logical"
] | [] | false | false | false | true | true | let partial_seq_agreement (x y: seq quad32) (lo hi: nat) =
| lo <= hi /\ hi <= length x /\ hi <= length y /\
(forall i. {:pattern (index x i)\/(index y i)} lo <= i /\ i < hi ==> index x i == index y i) | false |
|
Vale.AES.GCTR.fsti | Vale.AES.GCTR.aes_encrypt_BE | val aes_encrypt_BE (alg: algorithm) (key: seq nat32) (p_BE: quad32)
: Pure quad32 (requires is_aes_key_LE alg key) (ensures fun _ -> True) | val aes_encrypt_BE (alg: algorithm) (key: seq nat32) (p_BE: quad32)
: Pure quad32 (requires is_aes_key_LE alg key) (ensures fun _ -> True) | let aes_encrypt_BE (alg:algorithm) (key:seq nat32) (p_BE:quad32) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let p_LE = reverse_bytes_quad32 p_BE in
aes_encrypt_LE alg key p_LE | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 78,
"start_col": 0,
"start_line": 73
} | module Vale.AES.GCTR
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
let make_gctr_plain_LE (p:seq nat8) : seq nat8 =
if length p < pow2_32 then p else empty
let inc32lite (cb:quad32) (i:int) : quad32 =
if 0 <= i && i < pow2_32 then
let sum = cb.lo0 + i in
let lo0 = if sum >= pow2_32 then sum - pow2_32 else sum in
Mkfour lo0 cb.lo1 cb.hi2 cb.hi3
else
Mkfour 42 42 42 42
let empty_seq_quad32 : seq quad32 = empty
val lemma_counter_init (x:quad32) (low64 low8:nat64) : Lemma
(requires low64 == lo64 x /\
low8 == iand64 low64 0xff)
(ensures low8 == x.lo0 % 256)
let partial_seq_agreement (x y:seq quad32) (lo hi:nat) =
lo <= hi /\ hi <= length x /\ hi <= length y /\
(forall i . {:pattern (index x i) \/ (index y i)} lo <= i /\ i < hi ==> index x i == index y i)
(*
let lemma_partial_seq_agreement_subset (x y:seq quad32) (lo hi hi':nat) : Lemma
(requires lo <= hi /\ hi <= hi' /\ hi' <= length x /\ hi' <= length y /\
partial_seq_agreement x y lo hi')
(ensures partial_seq_agreement x y lo hi)
=
()
*)
(*
let lemma_partial_seq_agreement_step (x y z:seq quad32) (lo mid hi:nat) : Lemma
(requires partial_seq_agreement x y lo hi /\
length z >= hi /\
lo <= mid /\ mid < hi /\
(forall i . 0 <= i /\ i < length z /\ (i < lo || i > mid) ==>
index y i == index z i))
(ensures partial_seq_agreement x z (mid+1) hi)
=
()
*)
val gctr_encrypt_block_offset (icb_BE:quad32) (plain_LE:quad32) (alg:algorithm) (key:seq nat32) (i:int) : Lemma
(requires is_aes_key_LE alg key)
(ensures
gctr_encrypt_block icb_BE plain_LE alg key i ==
gctr_encrypt_block (inc32 icb_BE i) plain_LE alg key 0
)
val gctr_encrypt_empty (icb_BE:quad32) (plain_LE cipher_LE:seq quad32) (alg:algorithm) (key:seq nat32) : Lemma
(requires is_aes_key_LE alg key)
(ensures (
let plain = slice (le_seq_quad32_to_bytes plain_LE) 0 0 in
let cipher = slice (le_seq_quad32_to_bytes cipher_LE) 0 0 in
cipher = gctr_encrypt_LE icb_BE (make_gctr_plain_LE plain) alg key
)) | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.GCTR_s.fst.checked",
"Vale.AES.GCM_helpers.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
alg: Vale.AES.AES_common_s.algorithm ->
key: FStar.Seq.Base.seq Vale.Def.Types_s.nat32 ->
p_BE: Vale.Def.Types_s.quad32
-> Prims.Pure Vale.Def.Types_s.quad32 | Prims.Pure | [] | [] | [
"Vale.AES.AES_common_s.algorithm",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.Def.Types_s.quad32",
"Vale.AES.AES_s.aes_encrypt_LE",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.AES.AES_s.is_aes_key_LE",
"Prims.l_True"
] | [] | false | false | false | false | false | let aes_encrypt_BE (alg: algorithm) (key: seq nat32) (p_BE: quad32)
: Pure quad32 (requires is_aes_key_LE alg key) (ensures fun _ -> True) =
| let p_LE = reverse_bytes_quad32 p_BE in
aes_encrypt_LE alg key p_LE | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.to_mont_eval_lemma | val to_mont_eval_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
a * r2 * d % n == a * r % n)) | val to_mont_eval_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
a * r2 * d % n == a * r % n)) | let to_mont_eval_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let c = a * r2 in
calc (==) {
c * d % n;
(==) { }
a * r2 * d % n;
(==) { Math.Lemmas.paren_mul_right 2 pbits rLen;
Math.Lemmas.pow2_plus (pbits * rLen) (pbits * rLen) }
a * (r * r % n) * d % n;
(==) { lemma_mod_mul_distr3 a (r * r) d n }
a * (r * r) * d % n;
(==) { Math.Lemmas.paren_mul_right a r r }
a * r * r * d % n;
(==) { Math.Lemmas.paren_mul_right (a * r) r d }
a * r * (r * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (a * r) (r * d) n }
a * r * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a * r % n;
};
assert (c * d % n == a * r % n) | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 33,
"end_line": 579,
"start_col": 0,
"start_line": 555
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n))
let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n
val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n))
let mont_mul_lemma pbits rLen n mu a b =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b)
/// Lemma (to_mont rLen n mu a == a * r % n)
val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma
(a * (b % n) * c % n == a * b * c % n)
let lemma_mod_mul_distr3 a b c n =
calc (==) {
a * (b % n) * c % n;
(==) { }
(b % n) * a * c % n;
(==) { Math.Lemmas.paren_mul_right (b % n) a c }
(b % n) * (a * c) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l b (a * c) n }
b * (a * c) % n;
(==) { Math.Lemmas.paren_mul_right b a c }
a * b * c % n;
}
val mult_lt_lemma: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d)
let mult_lt_lemma a b c d = ()
val to_mont_eval_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
a * r2 * d % n == a * r % n)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | pbits: Prims.pos -> rLen: Prims.pos -> n: Prims.pos -> mu: Prims.nat -> a: Prims.nat
-> FStar.Pervasives.Lemma (requires Hacl.Spec.Montgomery.Lemmas.mont_pre pbits rLen n mu)
(ensures
(let r = Prims.pow2 (pbits * rLen) in
let r2 = Prims.pow2 ((2 * pbits) * rLen) % n in
let _ = Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd (pbits * rLen) n in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ d _ = _ in
(a * r2) * d % n == a * r % n)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.int",
"Prims._assert",
"Prims.eq2",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.paren_mul_right",
"Hacl.Spec.Montgomery.Lemmas.lemma_mod_mul_distr3",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Hacl.Spec.Montgomery.Lemmas.mont_preconditions_d",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd",
"Prims.pow2"
] | [] | false | false | true | false | false | let to_mont_eval_lemma pbits rLen n mu a =
| let r = pow2 (pbits * rLen) in
let r2 = pow2 ((2 * pbits) * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let c = a * r2 in
calc ( == ) {
c * d % n;
( == ) { () }
(a * r2) * d % n;
( == ) { (Math.Lemmas.paren_mul_right 2 pbits rLen;
Math.Lemmas.pow2_plus (pbits * rLen) (pbits * rLen)) }
(a * (r * r % n)) * d % n;
( == ) { lemma_mod_mul_distr3 a (r * r) d n }
(a * (r * r)) * d % n;
( == ) { Math.Lemmas.paren_mul_right a r r }
((a * r) * r) * d % n;
( == ) { Math.Lemmas.paren_mul_right (a * r) r d }
(a * r) * (r * d) % n;
( == ) { Math.Lemmas.lemma_mod_mul_distr_r (a * r) (r * d) n }
(a * r) * (r * d % n) % n;
( == ) { assert (r * d % n == 1) }
a * r % n;
};
assert (c * d % n == a * r % n) | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.from_mont_mul_lemma | val from_mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = mont_mul pbits rLen n mu aM bM in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == a * b % n)) | val from_mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = mont_mul pbits rLen n mu aM bM in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == a * b % n)) | let from_mont_mul_lemma pbits rLen n mu aM bM =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = mont_mul pbits rLen n mu aM bM in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
mont_mul_lemma pbits rLen n mu aM bM;
assert (cM == aM * bM * d % n);
from_mont_lemma pbits rLen n mu cM;
calc (==) { //c
cM * d % n;
(==) { }
(aM * bM * d % n) * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM * bM * d) d n }
aM * bM * d * d % n;
(==) { Math.Lemmas.paren_mul_right aM bM d }
aM * (bM * d) * d % n;
(==) {
Math.Lemmas.paren_mul_right aM (bM * d) d;
Math.Lemmas.swap_mul (bM * d) d;
Math.Lemmas.paren_mul_right aM d (bM * d) }
aM * d * (bM * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM * d) (bM * d) n }
(aM * d % n) * (bM * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (aM * d % n) (bM * d) n }
(aM * d % n) * (bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 799,
"start_col": 0,
"start_line": 765
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n))
let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n
val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n))
let mont_mul_lemma pbits rLen n mu a b =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b)
/// Lemma (to_mont rLen n mu a == a * r % n)
val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma
(a * (b % n) * c % n == a * b * c % n)
let lemma_mod_mul_distr3 a b c n =
calc (==) {
a * (b % n) * c % n;
(==) { }
(b % n) * a * c % n;
(==) { Math.Lemmas.paren_mul_right (b % n) a c }
(b % n) * (a * c) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l b (a * c) n }
b * (a * c) % n;
(==) { Math.Lemmas.paren_mul_right b a c }
a * b * c % n;
}
val mult_lt_lemma: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d)
let mult_lt_lemma a b c d = ()
val to_mont_eval_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
a * r2 * d % n == a * r % n))
let to_mont_eval_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let c = a * r2 in
calc (==) {
c * d % n;
(==) { }
a * r2 * d % n;
(==) { Math.Lemmas.paren_mul_right 2 pbits rLen;
Math.Lemmas.pow2_plus (pbits * rLen) (pbits * rLen) }
a * (r * r % n) * d % n;
(==) { lemma_mod_mul_distr3 a (r * r) d n }
a * (r * r) * d % n;
(==) { Math.Lemmas.paren_mul_right a r r }
a * r * r * d % n;
(==) { Math.Lemmas.paren_mul_right (a * r) r d }
a * r * (r * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (a * r) (r * d) n }
a * r * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a * r % n;
};
assert (c * d % n == a * r % n)
val to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < pow2 (pbits * rLen))
(ensures to_mont pbits rLen n mu a == a * pow2 (pbits * rLen) % n)
let to_mont_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let c = a * r2 in
let aM = to_mont pbits rLen n mu a in
assert (aM == mont_reduction pbits rLen n mu c);
mult_lt_lemma a r2 r n;
assert (a * r2 < r * n);
mont_reduction_lemma pbits rLen n mu c;
assert (aM == c * d % n);
to_mont_eval_lemma pbits rLen n mu a;
assert (aM == a * r % n)
/// Lemma (from_mont rLen n mu aM == aM * d % n)
val from_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ aM < pow2 (pbits * rLen))
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
from_mont pbits rLen n mu aM == aM * d % n))
let from_mont_lemma pbits rLen n mu aM =
mont_reduction_lemma pbits rLen n mu aM
/// Lemma (mont_one pbits rLen n mu == 1 * r % n)
val mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures mont_one pbits rLen n mu == 1 * pow2 (pbits * rLen) % n)
let mont_one_lemma pbits rLen n mu =
to_mont_lemma pbits rLen n mu 1
/// Properties of Montgomery arithmetic
// from_mont (to_mont a) = a % n
val lemma_mont_id: n:pos -> r:pos -> d:int{r * d % n == 1} -> a:nat ->
Lemma (a * r % n * d % n == a % n)
let lemma_mont_id n r d a =
calc (==) {
a * r % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * r) d n }
a * r * d % n;
(==) { Math.Lemmas.paren_mul_right a r d; Math.Lemmas.lemma_mod_mul_distr_r a (r * d) n }
a * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a % n;
}
// to_mont (mont_reduction a) = a % n
val lemma_mont_id1: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (a * d % n * r % n == a % n)
let lemma_mont_id1 n r d a =
calc (==) {
((a * d % n) * r) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * d) r n }
((a * d) * r) % n;
(==) { Math.Lemmas.paren_mul_right a d r }
(a * (d * r)) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r a (d * r) n }
(a * (d * r % n)) % n;
(==) { assert (r * d % n = 1) }
a % n;
};
assert (a * d % n * r % n == a % n)
// one_M * a = a
val lemma_mont_mul_one: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (let r0 = 1 * r % n in let r1 = a * r % n in r0 * r1 * d % n == r1 % n)
let lemma_mont_mul_one n r d a =
let r0 = 1 * r % n in
let r1 = a * r % n in
calc (==) {
r1 * r0 * d % n;
(==) { Math.Lemmas.paren_mul_right r1 r0 d; Math.Lemmas.lemma_mod_mul_distr_r r1 (r0 * d) n }
r1 * (r0 * d % n) % n;
(==) { lemma_mont_id n r d 1 }
r1 * (1 % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r r1 1 n }
r1 % n;
}
val from_mont_add_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = (aM + bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == (a + b) % n))
let from_mont_add_lemma pbits rLen n mu aM bM =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = (aM + bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
from_mont_lemma pbits rLen n mu cM;
assert (c == cM * d % n);
calc (==) { //c
cM * d % n;
(==) { }
(aM + bM) % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM + bM) d n }
(aM + bM) * d % n;
(==) { Math.Lemmas.distributivity_add_left aM bM d }
(aM * d + bM * d) % n;
(==) { Math.Lemmas.modulo_distributivity (aM * d) (bM * d) n }
(aM * d % n + bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM
val from_mont_sub_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = (aM - bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == (a - b) % n))
let from_mont_sub_lemma pbits rLen n mu aM bM =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = (aM - bM) % n in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
from_mont_lemma pbits rLen n mu cM;
assert (c == cM * d % n);
calc (==) { //c
cM * d % n;
(==) { }
(aM - bM) % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (aM - bM) d n }
(aM - bM) * d % n;
(==) { Math.Lemmas.distributivity_sub_left aM bM d }
(aM * d - bM * d) % n;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (aM * d) (- bM * d) n }
(aM * d % n - bM * d) % n;
(==) { Math.Lemmas.lemma_mod_sub_distr (aM * d % n) (bM * d) n }
(aM * d % n - bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM
val from_mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> bM:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\
aM < n /\ bM < n)
(ensures
(let cM = mont_mul pbits rLen n mu aM bM in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
c == a * b % n)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
pbits: Prims.pos ->
rLen: Prims.pos ->
n: Prims.pos ->
mu: Prims.nat ->
aM: Prims.nat ->
bM: Prims.nat
-> FStar.Pervasives.Lemma
(requires Hacl.Spec.Montgomery.Lemmas.mont_pre pbits rLen n mu /\ aM < n /\ bM < n)
(ensures
(let cM = Hacl.Spec.Montgomery.Lemmas.mont_mul pbits rLen n mu aM bM in
let c = Hacl.Spec.Montgomery.Lemmas.from_mont pbits rLen n mu cM in
let a = Hacl.Spec.Montgomery.Lemmas.from_mont pbits rLen n mu aM in
let b = Hacl.Spec.Montgomery.Lemmas.from_mont pbits rLen n mu bM in
c == a * b % n)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.int",
"Hacl.Spec.Montgomery.Lemmas.from_mont_lemma",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.lemma_mod_mul_distr_l",
"FStar.Math.Lemmas.paren_mul_right",
"FStar.Math.Lemmas.swap_mul",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Prims._assert",
"Hacl.Spec.Montgomery.Lemmas.mont_mul_lemma",
"Hacl.Spec.Montgomery.Lemmas.from_mont",
"Hacl.Spec.Montgomery.Lemmas.mont_mul",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd",
"Prims.pow2"
] | [] | false | false | true | false | false | let from_mont_mul_lemma pbits rLen n mu aM bM =
| let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let cM = mont_mul pbits rLen n mu aM bM in
let c = from_mont pbits rLen n mu cM in
let a = from_mont pbits rLen n mu aM in
let b = from_mont pbits rLen n mu bM in
mont_mul_lemma pbits rLen n mu aM bM;
assert (cM == (aM * bM) * d % n);
from_mont_lemma pbits rLen n mu cM;
calc ( == ) {
cM * d % n;
( == ) { () }
((aM * bM) * d % n) * d % n;
( == ) { Math.Lemmas.lemma_mod_mul_distr_l ((aM * bM) * d) d n }
((aM * bM) * d) * d % n;
( == ) { Math.Lemmas.paren_mul_right aM bM d }
(aM * (bM * d)) * d % n;
( == ) { (Math.Lemmas.paren_mul_right aM (bM * d) d;
Math.Lemmas.swap_mul (bM * d) d;
Math.Lemmas.paren_mul_right aM d (bM * d)) }
(aM * d) * (bM * d) % n;
( == ) { Math.Lemmas.lemma_mod_mul_distr_l (aM * d) (bM * d) n }
(aM * d % n) * (bM * d) % n;
( == ) { Math.Lemmas.lemma_mod_mul_distr_r (aM * d % n) (bM * d) n }
(aM * d % n) * (bM * d % n) % n;
};
from_mont_lemma pbits rLen n mu aM;
from_mont_lemma pbits rLen n mu bM | false |
Vale.AES.GCTR.fsti | Vale.AES.GCTR.gctr_registers_def | val gctr_registers_def
(r0 r1 r2 r3 r4 r5: quad32)
(s: seq quad32)
(alg: algorithm)
(key: seq nat32)
(ctr_BE: quad32)
(i: int)
: prop0 | val gctr_registers_def
(r0 r1 r2 r3 r4 r5: quad32)
(s: seq quad32)
(alg: algorithm)
(key: seq nat32)
(ctr_BE: quad32)
(i: int)
: prop0 | let gctr_registers_def (r0 r1 r2 r3 r4 r5:quad32) (s:seq quad32) (alg:algorithm) (key:seq nat32) (ctr_BE:quad32) (i:int) : prop0 =
0 <= i /\ i*6 + 5 < length s /\
is_aes_key_LE alg key /\
r0 = quad32_xor (index s (i*6 + 0)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 0))) /\
r1 = quad32_xor (index s (i*6 + 1)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 1))) /\
r2 = quad32_xor (index s (i*6 + 2)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 2))) /\
r3 = quad32_xor (index s (i*6 + 3)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 3))) /\
r4 = quad32_xor (index s (i*6 + 4)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 4))) /\
r5 = quad32_xor (index s (i*6 + 5)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6*i + 5))) | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 91,
"end_line": 88,
"start_col": 0,
"start_line": 80
} | module Vale.AES.GCTR
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
let make_gctr_plain_LE (p:seq nat8) : seq nat8 =
if length p < pow2_32 then p else empty
let inc32lite (cb:quad32) (i:int) : quad32 =
if 0 <= i && i < pow2_32 then
let sum = cb.lo0 + i in
let lo0 = if sum >= pow2_32 then sum - pow2_32 else sum in
Mkfour lo0 cb.lo1 cb.hi2 cb.hi3
else
Mkfour 42 42 42 42
let empty_seq_quad32 : seq quad32 = empty
val lemma_counter_init (x:quad32) (low64 low8:nat64) : Lemma
(requires low64 == lo64 x /\
low8 == iand64 low64 0xff)
(ensures low8 == x.lo0 % 256)
let partial_seq_agreement (x y:seq quad32) (lo hi:nat) =
lo <= hi /\ hi <= length x /\ hi <= length y /\
(forall i . {:pattern (index x i) \/ (index y i)} lo <= i /\ i < hi ==> index x i == index y i)
(*
let lemma_partial_seq_agreement_subset (x y:seq quad32) (lo hi hi':nat) : Lemma
(requires lo <= hi /\ hi <= hi' /\ hi' <= length x /\ hi' <= length y /\
partial_seq_agreement x y lo hi')
(ensures partial_seq_agreement x y lo hi)
=
()
*)
(*
let lemma_partial_seq_agreement_step (x y z:seq quad32) (lo mid hi:nat) : Lemma
(requires partial_seq_agreement x y lo hi /\
length z >= hi /\
lo <= mid /\ mid < hi /\
(forall i . 0 <= i /\ i < length z /\ (i < lo || i > mid) ==>
index y i == index z i))
(ensures partial_seq_agreement x z (mid+1) hi)
=
()
*)
val gctr_encrypt_block_offset (icb_BE:quad32) (plain_LE:quad32) (alg:algorithm) (key:seq nat32) (i:int) : Lemma
(requires is_aes_key_LE alg key)
(ensures
gctr_encrypt_block icb_BE plain_LE alg key i ==
gctr_encrypt_block (inc32 icb_BE i) plain_LE alg key 0
)
val gctr_encrypt_empty (icb_BE:quad32) (plain_LE cipher_LE:seq quad32) (alg:algorithm) (key:seq nat32) : Lemma
(requires is_aes_key_LE alg key)
(ensures (
let plain = slice (le_seq_quad32_to_bytes plain_LE) 0 0 in
let cipher = slice (le_seq_quad32_to_bytes cipher_LE) 0 0 in
cipher = gctr_encrypt_LE icb_BE (make_gctr_plain_LE plain) alg key
))
let aes_encrypt_BE (alg:algorithm) (key:seq nat32) (p_BE:quad32) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
let p_LE = reverse_bytes_quad32 p_BE in
aes_encrypt_LE alg key p_LE | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.GCTR_s.fst.checked",
"Vale.AES.GCM_helpers.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.GCTR.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r0: Vale.Def.Types_s.quad32 ->
r1: Vale.Def.Types_s.quad32 ->
r2: Vale.Def.Types_s.quad32 ->
r3: Vale.Def.Types_s.quad32 ->
r4: Vale.Def.Types_s.quad32 ->
r5: Vale.Def.Types_s.quad32 ->
s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
alg: Vale.AES.AES_common_s.algorithm ->
key: FStar.Seq.Base.seq Vale.Def.Types_s.nat32 ->
ctr_BE: Vale.Def.Types_s.quad32 ->
i: Prims.int
-> Vale.Def.Prop_s.prop0 | Prims.Tot | [
"total"
] | [] | [
"Vale.Def.Types_s.quad32",
"FStar.Seq.Base.seq",
"Vale.AES.AES_common_s.algorithm",
"Vale.Def.Types_s.nat32",
"Prims.int",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"FStar.Seq.Base.length",
"Vale.AES.AES_s.is_aes_key_LE",
"Prims.op_Equality",
"Vale.Def.Types_s.quad32_xor",
"FStar.Seq.Base.index",
"Vale.AES.GCTR.aes_encrypt_BE",
"Vale.AES.GCTR.inc32lite",
"Vale.Def.Prop_s.prop0"
] | [] | false | false | false | true | false | let gctr_registers_def
(r0 r1 r2 r3 r4 r5: quad32)
(s: seq quad32)
(alg: algorithm)
(key: seq nat32)
(ctr_BE: quad32)
(i: int)
: prop0 =
| 0 <= i /\ i * 6 + 5 < length s /\ is_aes_key_LE alg key /\
r0 = quad32_xor (index s (i * 6 + 0)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6 * i + 0))) /\
r1 = quad32_xor (index s (i * 6 + 1)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6 * i + 1))) /\
r2 = quad32_xor (index s (i * 6 + 2)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6 * i + 2))) /\
r3 = quad32_xor (index s (i * 6 + 3)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6 * i + 3))) /\
r4 = quad32_xor (index s (i * 6 + 4)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6 * i + 4))) /\
r5 = quad32_xor (index s (i * 6 + 5)) (aes_encrypt_BE alg key (inc32lite ctr_BE (6 * i + 5))) | false |
Hacl.Impl.P256.Verify.fst | Hacl.Impl.P256.Verify.ecdsa_verify_finv | val ecdsa_verify_finv: p:point -> r:felem -> Stack bool
(requires fun h ->
live h p /\ live h r /\ disjoint p r /\
point_inv h p /\ 0 < as_nat h r /\ as_nat h r < S.order)
//not (S.is_point_at_inf (from_mont_point (as_point_nat h p))))
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
(let (_X, _Y, _Z) = from_mont_point (as_point_nat h0 p) in
b <==> (S.fmul _X (S.finv _Z) % S.order = as_nat h0 r))) | val ecdsa_verify_finv: p:point -> r:felem -> Stack bool
(requires fun h ->
live h p /\ live h r /\ disjoint p r /\
point_inv h p /\ 0 < as_nat h r /\ as_nat h r < S.order)
//not (S.is_point_at_inf (from_mont_point (as_point_nat h p))))
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
(let (_X, _Y, _Z) = from_mont_point (as_point_nat h0 p) in
b <==> (S.fmul _X (S.finv _Z) % S.order = as_nat h0 r))) | let ecdsa_verify_finv p r_q =
push_frame ();
let x = create_felem () in
to_aff_point_x x p;
qmod_short x x;
let res = bn_is_eq_vartime4 x r_q in
pop_frame ();
res | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Verify.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 97,
"start_col": 0,
"start_line": 90
} | module Hacl.Impl.P256.Verify
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Point
open Hacl.Impl.P256.Scalar
open Hacl.Impl.P256.PointMul
module BSeq = Lib.ByteSequence
module S = Spec.P256
module SL = Spec.P256.Lemmas
module SM = Hacl.Spec.P256.Montgomery
module QI = Hacl.Impl.P256.Qinv
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let lbytes len = lbuffer uint8 len
val qmul_mont: sinv:felem -> b:felem -> res:felem -> Stack unit
(requires fun h ->
live h sinv /\ live h b /\ live h res /\
disjoint sinv res /\ disjoint b res /\
as_nat h sinv < S.order /\ as_nat h b < S.order)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_nat h1 res < S.order /\
as_nat h1 res = (as_nat h0 sinv * SM.from_qmont (as_nat h0 b) * SM.qmont_R_inv) % S.order)
[@CInline]
let qmul_mont sinv b res =
let h0 = ST.get () in
push_frame ();
let tmp = create_felem () in
from_qmont tmp b;
let h1 = ST.get () in
assert (as_nat h1 tmp == SM.from_qmont (as_nat h0 b));
qmul res sinv tmp;
let h2 = ST.get () in
assert (as_nat h2 res = (as_nat h1 sinv * as_nat h1 tmp * SM.qmont_R_inv) % S.order);
pop_frame ()
inline_for_extraction noextract
val ecdsa_verification_get_u12: u1:felem -> u2:felem -> r:felem -> s:felem -> z:felem -> Stack unit
(requires fun h ->
live h r /\ live h s /\ live h z /\ live h u1 /\ live h u2 /\
disjoint u1 u2 /\ disjoint u1 z /\ disjoint u1 r /\ disjoint u1 s /\
disjoint u2 z /\ disjoint u2 r /\ disjoint u2 s /\
as_nat h s < S.order /\ as_nat h z < S.order /\ as_nat h r < S.order)
(ensures fun h0 _ h1 -> modifies (loc u1 |+| loc u2) h0 h1 /\
(let sinv = S.qinv (as_nat h0 s) in
as_nat h1 u1 == sinv * as_nat h0 z % S.order /\
as_nat h1 u2 == sinv * as_nat h0 r % S.order))
let ecdsa_verification_get_u12 u1 u2 r s z =
push_frame ();
let h0 = ST.get () in
let sinv = create_felem () in
QI.qinv sinv s;
let h1 = ST.get () in
assert (qmont_as_nat h1 sinv == S.qinv (qmont_as_nat h0 s));
//assert (as_nat h2 sinv * SM.qmont_R_inv % S.order ==
//S.qinv (as_nat h1 sinv * SM.qmont_R_inv % S.order));
SM.qmont_inv_mul_lemma (as_nat h0 s) (as_nat h1 sinv) (as_nat h0 z);
SM.qmont_inv_mul_lemma (as_nat h0 s) (as_nat h1 sinv) (as_nat h0 r);
qmul_mont sinv z u1;
qmul_mont sinv r u2;
pop_frame ()
inline_for_extraction noextract
val ecdsa_verify_finv: p:point -> r:felem -> Stack bool
(requires fun h ->
live h p /\ live h r /\ disjoint p r /\
point_inv h p /\ 0 < as_nat h r /\ as_nat h r < S.order)
//not (S.is_point_at_inf (from_mont_point (as_point_nat h p))))
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
(let (_X, _Y, _Z) = from_mont_point (as_point_nat h0 p) in
b <==> (S.fmul _X (S.finv _Z) % S.order = as_nat h0 r))) | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Impl.P256.Scalar.fsti.checked",
"Hacl.Impl.P256.Qinv.fsti.checked",
"Hacl.Impl.P256.PointMul.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.P256.Verify.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Impl.P256.Qinv",
"short_module": "QI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.PointMul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: Hacl.Impl.P256.Point.point -> r: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.bool | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Bignum.felem",
"Prims.bool",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Hacl.Impl.P256.Bignum.bn_is_eq_vartime4",
"Hacl.Impl.P256.Scalar.qmod_short",
"Hacl.Impl.P256.Point.to_aff_point_x",
"Hacl.Impl.P256.Bignum.create_felem",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let ecdsa_verify_finv p r_q =
| push_frame ();
let x = create_felem () in
to_aff_point_x x p;
qmod_short x x;
let res = bn_is_eq_vartime4 x r_q in
pop_frame ();
res | false |
Spec.Poly1305.Test.fst | Spec.Poly1305.Test.msg | val msg:lbytes 34 | val msg:lbytes 34 | let msg : lbytes 34 =
let l = List.Tot.map u8_from_UInt8 [
0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy;
0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy;
0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy;
0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy;
0x75uy; 0x70uy
] in
assert_norm (List.Tot.length l == 34);
of_list l | {
"file_name": "specs/tests/Spec.Poly1305.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 27,
"start_col": 0,
"start_line": 18
} | module Spec.Poly1305.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Poly1305
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(* ********************* *)
(* RFC 7539 Test Vectors *)
(* ********************* *) | {
"checked_file": "/",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.IO.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Poly1305.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Poly1305",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 34 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let msg:lbytes 34 =
| let l =
List.Tot.map u8_from_UInt8
[
0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy;
0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy;
0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy
]
in
assert_norm (List.Tot.length l == 34);
of_list l | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd_k_lemma | val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1)) | val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1)) | let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 94,
"start_col": 0,
"start_line": 37
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Prims.pos -> n: Prims.pos -> k1: Prims.pos
-> FStar.Pervasives.Lemma (requires n * k1 % Prims.pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures
(let k =
(match n * k1 % Prims.pow2 a < Prims.pow2 (a - 1) with
| true -> k1
| _ -> k1 + Prims.pow2 (a - 1))
<:
Prims.int
in
n * k % Prims.pow2 a == 1)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.op_LessThan",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Subtraction",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Addition",
"Prims.op_Division",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.modulo_addition_lemma",
"FStar.Math.Lemmas.small_mod",
"FStar.Math.Lemmas.pow2_le_compat",
"Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd_k_lemma_d",
"Prims.bool",
"FStar.Math.Lemmas.distributivity_add_right",
"FStar.Math.Lemmas.distributivity_add_left",
"FStar.Math.Lemmas.lemma_div_exact",
"FStar.Math.Lemmas.paren_mul_right",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.euclidean_division_definition"
] | [] | false | false | true | false | false | let eea_pow2_odd_k_lemma a n k1 =
| let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc ( == ) {
n * k1;
( == ) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
( == ) { Math.Lemmas.euclidean_division_definition d 2 }
1 + ((d / 2) * 2 + d % 2) * pow2 (a - 1);
( == ) { Math.Lemmas.distributivity_add_left ((d / 2) * 2) (d % 2) (pow2 (a - 1)) }
1 + ((d / 2) * 2) * pow2 (a - 1) + (d % 2) * pow2 (a - 1);
( == ) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + (d / 2) * pow2 a + (d % 2) * pow2 (a - 1);
};
assert (n * k1 == 1 + (d / 2) * pow2 a + (d % 2) * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1)
then
(eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc ( == ) {
n * k % pow2 a;
( == ) { () }
(1 + (d / 2) * pow2 a) % pow2 a;
( == ) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
( == ) { (Math.Lemmas.pow2_le_compat a 1;
Math.Lemmas.small_mod 1 (pow2 a)) }
1;
};
assert (n * k % pow2 a = 1);
())
else
(eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + (d / 2) * pow2 a + pow2 (a - 1));
calc ( == ) {
n * k % pow2 a;
( == ) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
( == ) { () }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + (d / 2) * pow2 a) % pow2 a;
( == ) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1))
(pow2 a)
(d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
( == ) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
( == ) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (((1 + n) / 2) * 2) * pow2 (a - 1)) % pow2 a;
( == ) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + ((1 + n) / 2) * (2 * pow2 (a - 1))) % pow2 a;
( == ) { Math.Lemmas.pow2_plus 1 (a - 1) }
(1 + ((1 + n) / 2) * pow2 a) % pow2 a;
( == ) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
( == ) { (Math.Lemmas.pow2_le_compat a 1;
Math.Lemmas.small_mod 1 (pow2 a)) }
1;
};
assert (n * k % pow2 a == 1);
()) | false |
Hacl.Impl.P256.Verify.fst | Hacl.Impl.P256.Verify.qmul_mont | val qmul_mont: sinv:felem -> b:felem -> res:felem -> Stack unit
(requires fun h ->
live h sinv /\ live h b /\ live h res /\
disjoint sinv res /\ disjoint b res /\
as_nat h sinv < S.order /\ as_nat h b < S.order)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_nat h1 res < S.order /\
as_nat h1 res = (as_nat h0 sinv * SM.from_qmont (as_nat h0 b) * SM.qmont_R_inv) % S.order) | val qmul_mont: sinv:felem -> b:felem -> res:felem -> Stack unit
(requires fun h ->
live h sinv /\ live h b /\ live h res /\
disjoint sinv res /\ disjoint b res /\
as_nat h sinv < S.order /\ as_nat h b < S.order)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_nat h1 res < S.order /\
as_nat h1 res = (as_nat h0 sinv * SM.from_qmont (as_nat h0 b) * SM.qmont_R_inv) % S.order) | let qmul_mont sinv b res =
let h0 = ST.get () in
push_frame ();
let tmp = create_felem () in
from_qmont tmp b;
let h1 = ST.get () in
assert (as_nat h1 tmp == SM.from_qmont (as_nat h0 b));
qmul res sinv tmp;
let h2 = ST.get () in
assert (as_nat h2 res = (as_nat h1 sinv * as_nat h1 tmp * SM.qmont_R_inv) % S.order);
pop_frame () | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Verify.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 48,
"start_col": 0,
"start_line": 38
} | module Hacl.Impl.P256.Verify
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Point
open Hacl.Impl.P256.Scalar
open Hacl.Impl.P256.PointMul
module BSeq = Lib.ByteSequence
module S = Spec.P256
module SL = Spec.P256.Lemmas
module SM = Hacl.Spec.P256.Montgomery
module QI = Hacl.Impl.P256.Qinv
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let lbytes len = lbuffer uint8 len
val qmul_mont: sinv:felem -> b:felem -> res:felem -> Stack unit
(requires fun h ->
live h sinv /\ live h b /\ live h res /\
disjoint sinv res /\ disjoint b res /\
as_nat h sinv < S.order /\ as_nat h b < S.order)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_nat h1 res < S.order /\
as_nat h1 res = (as_nat h0 sinv * SM.from_qmont (as_nat h0 b) * SM.qmont_R_inv) % S.order) | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Impl.P256.Scalar.fsti.checked",
"Hacl.Impl.P256.Qinv.fsti.checked",
"Hacl.Impl.P256.PointMul.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.P256.Verify.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Impl.P256.Qinv",
"short_module": "QI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.PointMul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
sinv: Hacl.Impl.P256.Bignum.felem ->
b: Hacl.Impl.P256.Bignum.felem ->
res: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Hacl.Impl.P256.Bignum.as_nat",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Hacl.Spec.P256.Montgomery.qmont_R_inv",
"Spec.P256.PointOps.order",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Impl.P256.Scalar.qmul",
"Prims.eq2",
"Prims.nat",
"Hacl.Spec.P256.Montgomery.from_qmont",
"Hacl.Impl.P256.Scalar.from_qmont",
"Hacl.Impl.P256.Bignum.create_felem",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let qmul_mont sinv b res =
| let h0 = ST.get () in
push_frame ();
let tmp = create_felem () in
from_qmont tmp b;
let h1 = ST.get () in
assert (as_nat h1 tmp == SM.from_qmont (as_nat h0 b));
qmul res sinv tmp;
let h2 = ST.get () in
assert (as_nat h2 res = ((as_nat h1 sinv * as_nat h1 tmp) * SM.qmont_R_inv) % S.order);
pop_frame () | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Mtvsrws | val va_wp_Mtvsrws
(dst: va_operand_vec_opr)
(src: va_operand_reg_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Mtvsrws
(dst: va_operand_vec_opr)
(src: va_operand_reg_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 80,
"end_line": 212,
"start_col": 0,
"start_line": 203
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src: Vale.PPC64LE.Decls.va_operand_reg_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_reg_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Prims.int",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Prims.op_Modulus",
"Vale.PPC64LE.Decls.va_eval_reg_opr",
"Vale.PPC64LE.Machine_s.pow2_32",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Mtvsrws
(dst: va_operand_vec_opr)
(src: va_operand_reg_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
(va_eval_reg_opr va_s0 src)
`op_Modulus`
pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) ==
(va_eval_reg_opr va_s0 src)
`op_Modulus`
pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) ==
(va_eval_reg_opr va_s0 src)
`op_Modulus`
pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) ==
(va_eval_reg_opr va_s0 src)
`op_Modulus`
pow2_32 ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Mfvsrd | val va_wp_Mfvsrd
(dst: va_operand_reg_opr)
(src: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Mfvsrd
(dst: va_operand_reg_opr)
(src: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 81,
"start_col": 0,
"start_line": 76
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_reg_opr ->
src: Vale.PPC64LE.Decls.va_operand_vec_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_reg_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_reg_opr",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.PPC64LE.Decls.va_eval_reg_opr",
"Vale.Arch.Types.hi64",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_reg_opr"
] | [] | false | false | false | true | true | let va_wp_Mfvsrd
(dst: va_operand_reg_opr)
(src: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\
(forall (va_x_dst: va_value_reg_opr).
let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Mfvsrld | val va_wp_Mfvsrld
(dst: va_operand_reg_opr)
(src: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Mfvsrld
(dst: va_operand_reg_opr)
(src: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 115,
"start_col": 0,
"start_line": 110
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_reg_opr ->
src: Vale.PPC64LE.Decls.va_operand_vec_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_reg_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_reg_opr",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.PPC64LE.Decls.va_eval_reg_opr",
"Vale.Arch.Types.lo64",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_reg_opr"
] | [] | false | false | false | true | true | let va_wp_Mfvsrld
(dst: va_operand_reg_opr)
(src: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\
(forall (va_x_dst: va_value_reg_opr).
let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Vmr | val va_wp_Vmr (dst src: va_operand_vec_opr) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vmr (dst src: va_operand_vec_opr) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 99,
"end_line": 47,
"start_col": 0,
"start_line": 43
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src: Vale.PPC64LE.Decls.va_operand_vec_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Vale.PPC64LE.Machine_s.quad32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Vmr (dst src: va_operand_vec_opr) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (()))
) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Vxor | val va_wp_Vxor
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vxor
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 83,
"end_line": 287,
"start_col": 0,
"start_line": 282
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Types_s.quad32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Types_s.quad32_xor",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Vxor
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_vec_opr va_sM dst ==
Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Vadduwm | val va_wp_Vadduwm
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vadduwm
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 250,
"start_col": 0,
"start_line": 244
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Types_s.quad32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Arch.Types.add_wrap_quad32",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Vadduwm
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Vand | val va_wp_Vand
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vand
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 327,
"start_col": 0,
"start_line": 320
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Words.Four_s.four_map2",
"Vale.PPC64LE.Memory.nat32",
"Vale.Arch.Types.iand32",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Vand
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32
#Vale.Def.Types_s.nat32
(fun (di: nat32) (si: nat32) -> Vale.Arch.Types.iand32 di si)
(va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Vsrw | val va_wp_Vsrw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vsrw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 433,
"start_col": 0,
"start_line": 419
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Words_s.Mkfour",
"Vale.Arch.Types.ishr32",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Prims.op_Modulus",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Vsrw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))
((Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
`op_Modulus`
32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1))
((Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
`op_Modulus`
32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1))
((Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
`op_Modulus`
32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))
((Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
`op_Modulus`
32)) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Vslw | val va_wp_Vslw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vslw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 380,
"start_col": 0,
"start_line": 366
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Words_s.Mkfour",
"Vale.Arch.Types.ishl32",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Prims.op_Modulus",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Vslw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))
((Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
`op_Modulus`
32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1))
((Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
`op_Modulus`
32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1))
((Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
`op_Modulus`
32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))
((Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
`op_Modulus`
32)) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Xxmrghd | val va_wp_Xxmrghd
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Xxmrghd
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 99,
"end_line": 708,
"start_col": 0,
"start_line": 700
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Xxmrghd
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Vmrghw | val va_wp_Vmrghw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vmrghw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 99,
"end_line": 665,
"start_col": 0,
"start_line": 657
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Vmrghw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Vsel | val va_wp_Vsel
(dst src1 src2 sel: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vsel
(dst src1 src2 sel: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_is_src_vec_opr sel va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 98,
"end_line": 775,
"start_col": 0,
"start_line": 755
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Xxmrghd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
(va_QProc (va_code_Xxmrghd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2))
//--
//-- Vsel
val va_code_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
sel:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> sel:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsel : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> sel:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsel dst src1 src2 sel) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_is_src_vec_opr sel
va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr ->
sel: Vale.PPC64LE.Decls.va_operand_vec_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Sel.isel32",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Vsel
(dst src1 src2 sel: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_is_src_vec_opr sel va_s0 /\ va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Sel.isel32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Sel.isel32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Sel.isel32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Sel.isel32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) ==>
va_k va_sM (()))) | false |
Hacl.Impl.P256.Verify.fst | Hacl.Impl.P256.Verify.ecdsa_verification_get_u12 | val ecdsa_verification_get_u12: u1:felem -> u2:felem -> r:felem -> s:felem -> z:felem -> Stack unit
(requires fun h ->
live h r /\ live h s /\ live h z /\ live h u1 /\ live h u2 /\
disjoint u1 u2 /\ disjoint u1 z /\ disjoint u1 r /\ disjoint u1 s /\
disjoint u2 z /\ disjoint u2 r /\ disjoint u2 s /\
as_nat h s < S.order /\ as_nat h z < S.order /\ as_nat h r < S.order)
(ensures fun h0 _ h1 -> modifies (loc u1 |+| loc u2) h0 h1 /\
(let sinv = S.qinv (as_nat h0 s) in
as_nat h1 u1 == sinv * as_nat h0 z % S.order /\
as_nat h1 u2 == sinv * as_nat h0 r % S.order)) | val ecdsa_verification_get_u12: u1:felem -> u2:felem -> r:felem -> s:felem -> z:felem -> Stack unit
(requires fun h ->
live h r /\ live h s /\ live h z /\ live h u1 /\ live h u2 /\
disjoint u1 u2 /\ disjoint u1 z /\ disjoint u1 r /\ disjoint u1 s /\
disjoint u2 z /\ disjoint u2 r /\ disjoint u2 s /\
as_nat h s < S.order /\ as_nat h z < S.order /\ as_nat h r < S.order)
(ensures fun h0 _ h1 -> modifies (loc u1 |+| loc u2) h0 h1 /\
(let sinv = S.qinv (as_nat h0 s) in
as_nat h1 u1 == sinv * as_nat h0 z % S.order /\
as_nat h1 u2 == sinv * as_nat h0 r % S.order)) | let ecdsa_verification_get_u12 u1 u2 r s z =
push_frame ();
let h0 = ST.get () in
let sinv = create_felem () in
QI.qinv sinv s;
let h1 = ST.get () in
assert (qmont_as_nat h1 sinv == S.qinv (qmont_as_nat h0 s));
//assert (as_nat h2 sinv * SM.qmont_R_inv % S.order ==
//S.qinv (as_nat h1 sinv * SM.qmont_R_inv % S.order));
SM.qmont_inv_mul_lemma (as_nat h0 s) (as_nat h1 sinv) (as_nat h0 z);
SM.qmont_inv_mul_lemma (as_nat h0 s) (as_nat h1 sinv) (as_nat h0 r);
qmul_mont sinv z u1;
qmul_mont sinv r u2;
pop_frame () | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Verify.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 77,
"start_col": 0,
"start_line": 63
} | module Hacl.Impl.P256.Verify
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
open Hacl.Impl.P256.Point
open Hacl.Impl.P256.Scalar
open Hacl.Impl.P256.PointMul
module BSeq = Lib.ByteSequence
module S = Spec.P256
module SL = Spec.P256.Lemmas
module SM = Hacl.Spec.P256.Montgomery
module QI = Hacl.Impl.P256.Qinv
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let lbytes len = lbuffer uint8 len
val qmul_mont: sinv:felem -> b:felem -> res:felem -> Stack unit
(requires fun h ->
live h sinv /\ live h b /\ live h res /\
disjoint sinv res /\ disjoint b res /\
as_nat h sinv < S.order /\ as_nat h b < S.order)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_nat h1 res < S.order /\
as_nat h1 res = (as_nat h0 sinv * SM.from_qmont (as_nat h0 b) * SM.qmont_R_inv) % S.order)
[@CInline]
let qmul_mont sinv b res =
let h0 = ST.get () in
push_frame ();
let tmp = create_felem () in
from_qmont tmp b;
let h1 = ST.get () in
assert (as_nat h1 tmp == SM.from_qmont (as_nat h0 b));
qmul res sinv tmp;
let h2 = ST.get () in
assert (as_nat h2 res = (as_nat h1 sinv * as_nat h1 tmp * SM.qmont_R_inv) % S.order);
pop_frame ()
inline_for_extraction noextract
val ecdsa_verification_get_u12: u1:felem -> u2:felem -> r:felem -> s:felem -> z:felem -> Stack unit
(requires fun h ->
live h r /\ live h s /\ live h z /\ live h u1 /\ live h u2 /\
disjoint u1 u2 /\ disjoint u1 z /\ disjoint u1 r /\ disjoint u1 s /\
disjoint u2 z /\ disjoint u2 r /\ disjoint u2 s /\
as_nat h s < S.order /\ as_nat h z < S.order /\ as_nat h r < S.order)
(ensures fun h0 _ h1 -> modifies (loc u1 |+| loc u2) h0 h1 /\
(let sinv = S.qinv (as_nat h0 s) in
as_nat h1 u1 == sinv * as_nat h0 z % S.order /\
as_nat h1 u2 == sinv * as_nat h0 r % S.order)) | {
"checked_file": "/",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Impl.P256.Scalar.fsti.checked",
"Hacl.Impl.P256.Qinv.fsti.checked",
"Hacl.Impl.P256.PointMul.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.P256.Bignum.fsti.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.P256.Verify.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Impl.P256.Qinv",
"short_module": "QI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.PointMul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
u1: Hacl.Impl.P256.Bignum.felem ->
u2: Hacl.Impl.P256.Bignum.felem ->
r: Hacl.Impl.P256.Bignum.felem ->
s: Hacl.Impl.P256.Bignum.felem ->
z: Hacl.Impl.P256.Bignum.felem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.P256.Bignum.felem",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Impl.P256.Verify.qmul_mont",
"Hacl.Spec.P256.Montgomery.qmont_inv_mul_lemma",
"Hacl.Impl.P256.Bignum.as_nat",
"Prims._assert",
"Prims.eq2",
"Spec.P256.PointOps.qelem",
"Hacl.Impl.P256.Scalar.qmont_as_nat",
"Spec.P256.PointOps.qinv",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Impl.P256.Qinv.qinv",
"Hacl.Impl.P256.Bignum.create_felem",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let ecdsa_verification_get_u12 u1 u2 r s z =
| push_frame ();
let h0 = ST.get () in
let sinv = create_felem () in
QI.qinv sinv s;
let h1 = ST.get () in
assert (qmont_as_nat h1 sinv == S.qinv (qmont_as_nat h0 s));
SM.qmont_inv_mul_lemma (as_nat h0 s) (as_nat h1 sinv) (as_nat h0 z);
SM.qmont_inv_mul_lemma (as_nat h0 s) (as_nat h1 sinv) (as_nat h0 r);
qmul_mont sinv z u1;
qmul_mont sinv r u2;
pop_frame () | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Vspltisw | val va_wp_Vspltisw
(dst: va_operand_vec_opr)
(src: sim)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vspltisw
(dst: va_operand_vec_opr)
(src: sim)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vspltisw (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat32 =
Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 90,
"end_line": 881,
"start_col": 0,
"start_line": 876
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Xxmrghd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
(va_QProc (va_code_Xxmrghd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2))
//--
//-- Vsel
val va_code_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
sel:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> sel:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsel : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> sel:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsel dst src1 src2 sel) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_is_src_vec_opr sel
va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_is_src_vec_opr sel va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) ==> va_k va_sM (())))
val va_wpProof_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> sel:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsel dst src1 src2 sel va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsel dst src1 src2 sel)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) : (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) =
(va_QProc (va_code_Vsel dst src1 src2 sel) ([va_mod_vec_opr dst]) (va_wp_Vsel dst src1 src2 sel)
(va_wpProof_Vsel dst src1 src2 sel))
//--
//-- Vspltw
val va_code_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot va_code
val va_codegen_success_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot
va_pbool
val va_lemma_Vspltw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> uim:nat2
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltw dst src uim) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltw dst src uim va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltw dst src uim) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) : (va_quickCode
unit (va_code_Vspltw dst src uim)) =
(va_QProc (va_code_Vspltw dst src uim) ([va_mod_vec_opr dst]) (va_wp_Vspltw dst src uim)
(va_wpProof_Vspltw dst src uim))
//--
//-- Vspltisw
val va_code_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisw dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat32 = Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src: Vale.PPC64LE.Machine_s.sim ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Machine_s.sim",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Words_s.nat32",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.int",
"Vale.PPC64LE.Machine_s.int_to_nat32",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Vspltisw
(dst: va_operand_vec_opr)
(src: sim)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
(let src_nat32 = Vale.PPC64LE.Machine_s.int_to_nat32 src in
va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Vsldoi | val va_wp_Vsldoi
(dst src1 src2: va_operand_vec_opr)
(count: quad32bytes)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vsldoi
(dst src1 src2: va_operand_vec_opr)
(count: quad32bytes)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 100,
"end_line": 622,
"start_col": 0,
"start_line": 603
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr ->
count: Vale.PPC64LE.Machine_s.quad32bytes ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Machine_s.quad32bytes",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_or",
"Prims.eq2",
"Prims.int",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Vsldoi
(dst src1 src2: va_operand_vec_opr)
(count: quad32bytes)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
(count == 4 ==>
va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\
(count == 8 ==>
va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\
(count == 12 ==>
va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Vspltw | val va_wp_Vspltw
(dst src: va_operand_vec_opr)
(uim: nat2)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vspltw
(dst src: va_operand_vec_opr)
(uim: nat2)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 99,
"end_line": 847,
"start_col": 0,
"start_line": 824
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Xxmrghd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
(va_QProc (va_code_Xxmrghd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2))
//--
//-- Vsel
val va_code_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
sel:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> sel:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsel : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> sel:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsel dst src1 src2 sel) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_is_src_vec_opr sel
va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_is_src_vec_opr sel va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) ==> va_k va_sM (())))
val va_wpProof_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> sel:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsel dst src1 src2 sel va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsel dst src1 src2 sel)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) : (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) =
(va_QProc (va_code_Vsel dst src1 src2 sel) ([va_mod_vec_opr dst]) (va_wp_Vsel dst src1 src2 sel)
(va_wpProof_Vsel dst src1 src2 sel))
//--
//-- Vspltw
val va_code_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot va_code
val va_codegen_success_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot
va_pbool
val va_lemma_Vspltw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> uim:nat2
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltw dst src uim) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src: Vale.PPC64LE.Decls.va_operand_vec_opr ->
uim: Vale.Def.Words_s.nat2 ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.Def.Words_s.nat2",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Prims.int",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Vspltw
(dst src: va_operand_vec_opr)
(uim: nat2)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
(uim == 0 ==>
va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\
(uim == 1 ==>
va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\
(uim == 2 ==>
va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\
(uim == 3 ==>
va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Load128_buffer | val va_wp_Load128_buffer
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Load128_buffer
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr) (base:va_operand_reg_opr)
(offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) false /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall (va_x_dst:va_value_vec_opr) .
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr
va_sM dst == Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) ==> va_k va_sM
(()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 973,
"start_col": 0,
"start_line": 960
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Xxmrghd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
(va_QProc (va_code_Xxmrghd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2))
//--
//-- Vsel
val va_code_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
sel:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> sel:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsel : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> sel:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsel dst src1 src2 sel) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_is_src_vec_opr sel
va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_is_src_vec_opr sel va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) ==> va_k va_sM (())))
val va_wpProof_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> sel:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsel dst src1 src2 sel va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsel dst src1 src2 sel)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) : (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) =
(va_QProc (va_code_Vsel dst src1 src2 sel) ([va_mod_vec_opr dst]) (va_wp_Vsel dst src1 src2 sel)
(va_wpProof_Vsel dst src1 src2 sel))
//--
//-- Vspltw
val va_code_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot va_code
val va_codegen_success_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot
va_pbool
val va_lemma_Vspltw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> uim:nat2
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltw dst src uim) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltw dst src uim va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltw dst src uim) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) : (va_quickCode
unit (va_code_Vspltw dst src uim)) =
(va_QProc (va_code_Vspltw dst src uim) ([va_mod_vec_opr dst]) (va_wp_Vspltw dst src uim)
(va_wpProof_Vspltw dst src uim))
//--
//-- Vspltisw
val va_code_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisw dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat32 = Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltisw (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat32 =
Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==> va_k va_sM (())))
val va_wpProof_Vspltisw : dst:va_operand_vec_opr -> src:sim -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltisw dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltisw dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltisw (dst:va_operand_vec_opr) (src:sim) : (va_quickCode unit (va_code_Vspltisw dst
src)) =
(va_QProc (va_code_Vspltisw dst src) ([va_mod_vec_opr dst]) (va_wp_Vspltisw dst src)
(va_wpProof_Vspltisw dst src))
//--
//-- Vspltisb
val va_code_Vspltisb : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisb : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisb : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisb dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat8 = Vale.PPC64LE.Machine_s.int_to_nat8 src in let src_nat32 =
Vale.Def.Types_s.be_bytes_to_nat32 (Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8
(Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)) in
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32
src_nat32 src_nat32 src_nat32) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltisb (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat8 =
Vale.PPC64LE.Machine_s.int_to_nat8 src in let src_nat32 = Vale.Def.Types_s.be_bytes_to_nat32
(Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8 (Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)) in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==>
va_k va_sM (())))
val va_wpProof_Vspltisb : dst:va_operand_vec_opr -> src:sim -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltisb dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltisb dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltisb (dst:va_operand_vec_opr) (src:sim) : (va_quickCode unit (va_code_Vspltisb dst
src)) =
(va_QProc (va_code_Vspltisb dst src) ([va_mod_vec_opr dst]) (va_wp_Vspltisb dst src)
(va_wpProof_Vspltisb dst src))
//--
//-- Load128_buffer
val va_code_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_buffer h dst base offset t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) false /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM
h) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
base: Vale.PPC64LE.Decls.va_operand_reg_opr ->
offset: Vale.PPC64LE.Decls.va_operand_reg_opr ->
t: Vale.Arch.HeapTypes_s.taint ->
b: Vale.PPC64LE.Memory.buffer128 ->
index: Prims.int ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_heaplet",
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.Arch.HeapTypes_s.taint",
"Vale.PPC64LE.Memory.buffer128",
"Prims.int",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_src_heaplet",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_reg_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Vale.PPC64LE.Decls.valid_src_addr",
"Vale.PPC64LE.Memory.vuint128",
"Vale.PPC64LE.Decls.va_eval_heaplet",
"Vale.PPC64LE.Memory.valid_layout_buffer",
"Vale.PPC64LE.Decls.va_get_mem_layout",
"Vale.PPC64LE.Memory.valid_taint_buf128",
"Vale.Arch.HeapImpl.__proj__Mkvale_heap_layout__item__vl_taint",
"Prims.eq2",
"Prims.op_Addition",
"Vale.PPC64LE.Decls.va_eval_reg_opr",
"Vale.PPC64LE.Memory.buffer_addr",
"Prims.op_Multiply",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Vale.PPC64LE.Machine_s.quad32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.PPC64LE.Decls.buffer128_read",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Load128_buffer
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\
Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128
b
(va_get_mem_layout va_s0)
(va_eval_heaplet va_s0 h)
false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h)
((va_get_mem_layout va_s0).vl_taint)
t /\
va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) +
16
`op_Multiply`
index /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_vec_opr va_sM dst ==
Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Vspltisb | val va_wp_Vspltisb
(dst: va_operand_vec_opr)
(src: sim)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vspltisb
(dst: va_operand_vec_opr)
(src: sim)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vspltisb (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat8 =
Vale.PPC64LE.Machine_s.int_to_nat8 src in let src_nat32 = Vale.Def.Types_s.be_bytes_to_nat32
(Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8 (Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)) in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==>
va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 921,
"start_col": 0,
"start_line": 913
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Xxmrghd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
(va_QProc (va_code_Xxmrghd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2))
//--
//-- Vsel
val va_code_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
sel:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> sel:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsel : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> sel:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsel dst src1 src2 sel) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_is_src_vec_opr sel
va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_is_src_vec_opr sel va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) ==> va_k va_sM (())))
val va_wpProof_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> sel:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsel dst src1 src2 sel va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsel dst src1 src2 sel)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) : (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) =
(va_QProc (va_code_Vsel dst src1 src2 sel) ([va_mod_vec_opr dst]) (va_wp_Vsel dst src1 src2 sel)
(va_wpProof_Vsel dst src1 src2 sel))
//--
//-- Vspltw
val va_code_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot va_code
val va_codegen_success_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot
va_pbool
val va_lemma_Vspltw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> uim:nat2
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltw dst src uim) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltw dst src uim va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltw dst src uim) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) : (va_quickCode
unit (va_code_Vspltw dst src uim)) =
(va_QProc (va_code_Vspltw dst src uim) ([va_mod_vec_opr dst]) (va_wp_Vspltw dst src uim)
(va_wpProof_Vspltw dst src uim))
//--
//-- Vspltisw
val va_code_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisw dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat32 = Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltisw (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat32 =
Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==> va_k va_sM (())))
val va_wpProof_Vspltisw : dst:va_operand_vec_opr -> src:sim -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltisw dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltisw dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltisw (dst:va_operand_vec_opr) (src:sim) : (va_quickCode unit (va_code_Vspltisw dst
src)) =
(va_QProc (va_code_Vspltisw dst src) ([va_mod_vec_opr dst]) (va_wp_Vspltisw dst src)
(va_wpProof_Vspltisw dst src))
//--
//-- Vspltisb
val va_code_Vspltisb : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisb : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisb : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisb dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat8 = Vale.PPC64LE.Machine_s.int_to_nat8 src in let src_nat32 =
Vale.Def.Types_s.be_bytes_to_nat32 (Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8
(Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)) in
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32
src_nat32 src_nat32 src_nat32) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src: Vale.PPC64LE.Machine_s.sim ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Machine_s.sim",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Words_s.nat32",
"Vale.Def.Types_s.be_bytes_to_nat32",
"Vale.Def.Words.Seq_s.four_to_seq_BE",
"Vale.Def.Types_s.nat8",
"Vale.Def.Words_s.nat8",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.int",
"Vale.PPC64LE.Machine_s.int_to_nat8",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Vspltisb
(dst: va_operand_vec_opr)
(src: sim)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
(let src_nat8 = Vale.PPC64LE.Machine_s.int_to_nat8 src in
let src_nat32 =
Vale.Def.Types_s.be_bytes_to_nat32 (Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8
(Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)
)
in
va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Load128_word4_buffer | val va_wp_Load128_word4_buffer
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Load128_word4_buffer
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Load128_word4_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let buf = Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM
h) in l_and (l_and (l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM
dst) == Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf)
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 74,
"end_line": 1093,
"start_col": 0,
"start_line": 1075
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Xxmrghd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
(va_QProc (va_code_Xxmrghd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2))
//--
//-- Vsel
val va_code_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
sel:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> sel:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsel : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> sel:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsel dst src1 src2 sel) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_is_src_vec_opr sel
va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_is_src_vec_opr sel va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) ==> va_k va_sM (())))
val va_wpProof_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> sel:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsel dst src1 src2 sel va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsel dst src1 src2 sel)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) : (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) =
(va_QProc (va_code_Vsel dst src1 src2 sel) ([va_mod_vec_opr dst]) (va_wp_Vsel dst src1 src2 sel)
(va_wpProof_Vsel dst src1 src2 sel))
//--
//-- Vspltw
val va_code_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot va_code
val va_codegen_success_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot
va_pbool
val va_lemma_Vspltw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> uim:nat2
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltw dst src uim) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltw dst src uim va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltw dst src uim) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) : (va_quickCode
unit (va_code_Vspltw dst src uim)) =
(va_QProc (va_code_Vspltw dst src uim) ([va_mod_vec_opr dst]) (va_wp_Vspltw dst src uim)
(va_wpProof_Vspltw dst src uim))
//--
//-- Vspltisw
val va_code_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisw dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat32 = Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltisw (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat32 =
Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==> va_k va_sM (())))
val va_wpProof_Vspltisw : dst:va_operand_vec_opr -> src:sim -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltisw dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltisw dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltisw (dst:va_operand_vec_opr) (src:sim) : (va_quickCode unit (va_code_Vspltisw dst
src)) =
(va_QProc (va_code_Vspltisw dst src) ([va_mod_vec_opr dst]) (va_wp_Vspltisw dst src)
(va_wpProof_Vspltisw dst src))
//--
//-- Vspltisb
val va_code_Vspltisb : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisb : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisb : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisb dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat8 = Vale.PPC64LE.Machine_s.int_to_nat8 src in let src_nat32 =
Vale.Def.Types_s.be_bytes_to_nat32 (Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8
(Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)) in
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32
src_nat32 src_nat32 src_nat32) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltisb (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat8 =
Vale.PPC64LE.Machine_s.int_to_nat8 src in let src_nat32 = Vale.Def.Types_s.be_bytes_to_nat32
(Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8 (Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)) in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==>
va_k va_sM (())))
val va_wpProof_Vspltisb : dst:va_operand_vec_opr -> src:sim -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltisb dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltisb dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltisb (dst:va_operand_vec_opr) (src:sim) : (va_quickCode unit (va_code_Vspltisb dst
src)) =
(va_QProc (va_code_Vspltisb dst src) ([va_mod_vec_opr dst]) (va_wp_Vspltisb dst src)
(va_wpProof_Vspltisb dst src))
//--
//-- Load128_buffer
val va_code_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_buffer h dst base offset t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) false /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM
h) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr) (base:va_operand_reg_opr)
(offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) false /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall (va_x_dst:va_value_vec_opr) .
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr
va_sM dst == Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) ==> va_k va_sM
(())))
val va_wpProof_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_buffer h dst base offset t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load128_buffer h dst base offset t)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_Load128_buffer h dst base offset t)) =
(va_QProc (va_code_Load128_buffer h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_buffer h dst base offset t b index) (va_wpProof_Load128_buffer h dst base offset
t b index))
//--
//-- Store128_buffer
val va_code_Store128_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Store128_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
src:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Store128_buffer h src base offset t) va_s0 /\
va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_dst_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) true /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_heaplet va_sM h == buffer128_write b index (va_eval_vec_opr va_s0 src) (va_eval_heaplet
va_s0 h) /\ va_state_eq va_sM (va_update_mem va_sM (va_update_ok va_sM
(va_update_operand_heaplet h va_sM va_s0)))))
[@ va_qattr]
let va_wp_Store128_buffer (h:va_operand_heaplet) (src:va_operand_vec_opr) (base:va_operand_reg_opr)
(offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_dst_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) true /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall (va_x_h:va_value_heaplet)
(va_x_mem:vale_heap) . let va_sM = va_upd_mem va_x_mem (va_upd_operand_heaplet h va_x_h va_s0)
in va_get_ok va_sM /\ va_eval_heaplet va_sM h == buffer128_write b index (va_eval_vec_opr va_s0
src) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Store128_buffer h src base offset t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Store128_buffer h src base offset t)
([va_Mod_mem; va_mod_heaplet h]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Store128_buffer (h:va_operand_heaplet) (src:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_Store128_buffer h src base offset t)) =
(va_QProc (va_code_Store128_buffer h src base offset t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_buffer h src base offset t b index) (va_wpProof_Store128_buffer h src base
offset t b index))
//--
//-- Load128_word4_buffer
val va_code_Load128_word4_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_word4_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_word4_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_vec_opr -> base:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_word4_buffer h dst base t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let buf = Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) in l_and (l_and
(l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf) (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
base: Vale.PPC64LE.Decls.va_operand_reg_opr ->
t: Vale.Arch.HeapTypes_s.taint ->
b: Vale.PPC64LE.Memory.buffer128 ->
index: Prims.int ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_heaplet",
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.Arch.HeapTypes_s.taint",
"Vale.PPC64LE.Memory.buffer128",
"Prims.int",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_src_heaplet",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_reg_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Vale.PPC64LE.Decls.valid_src_addr",
"Vale.PPC64LE.Memory.vuint128",
"Vale.PPC64LE.Decls.va_eval_heaplet",
"Vale.PPC64LE.Memory.valid_layout_buffer",
"Vale.PPC64LE.Decls.va_get_mem_layout",
"Vale.PPC64LE.Memory.valid_taint_buf128",
"Vale.Arch.HeapImpl.__proj__Mkvale_heap_layout__item__vl_taint",
"Prims.eq2",
"Vale.PPC64LE.Decls.va_eval_reg_opr",
"Prims.op_Addition",
"Vale.PPC64LE.Memory.buffer_addr",
"Prims.op_Multiply",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Types_s.quad32",
"Vale.PPC64LE.Decls.buffer128_read",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Load128_word4_buffer
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\
Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128
b
(va_get_mem_layout va_s0)
(va_eval_heaplet va_s0 h)
false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h)
((va_get_mem_layout va_s0).vl_taint)
t /\
va_eval_reg_opr va_s0 base ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) +
16
`op_Multiply`
index /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
(let buf = Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) in
l_and (l_and (l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf)
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) ==>
va_k va_sM (()))) | false |
Pulse.Checker.Prover.IntroPure.fst | Pulse.Checker.Prover.IntroPure.is_host_var | val is_host_var : x: FStar.Stubs.Reflection.Types.term -> FStar.Pervasives.Native.option Pulse.Syntax.Base.nm | let is_host_var (x:R.term) =
match R.inspect_ln x with
| R.Tv_Var nv ->
let nv_view = R.inspect_namedv nv in
Some {nm_index=nv_view.uniq;
nm_ppname=mk_ppname (nv_view.ppname) (R.range_of_term x)}
| _ -> None | {
"file_name": "lib/steel/pulse/Pulse.Checker.Prover.IntroPure.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 13,
"end_line": 121,
"start_col": 0,
"start_line": 115
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Pulse.Checker.Prover.IntroPure
open Pulse.Syntax
open Pulse.Typing
open Pulse.Typing.Combinators
open Pulse.Typing.Metatheory
open Pulse.Checker.Pure
open Pulse.Checker.VPropEquiv
open Pulse.Checker.Prover.Base
open Pulse.Checker.Base
open Pulse.Checker.Prover.Util
module RU = Pulse.RuntimeUtils
module T = FStar.Tactics.V2
module P = Pulse.Syntax.Printer
module PS = Pulse.Checker.Prover.Substs
let coerce_eq (#a #b:Type) (x:a) (_:squash (a == b)) : y:b{y == x} = x
let k_intro_pure (g:env) (p:term)
(d:tot_typing g p tm_prop)
(token:prop_validity g p) (frame:vprop)
: T.Tac (continuation_elaborator g frame g (frame * tm_pure p)) =
let t = wtag (Some STT_Ghost) (Tm_IntroPure {p}) in
let c = comp_intro_pure p in
let d : st_typing g t c = T_IntroPure g p d token in
let x = fresh g in
// p is well-typed in g, so it does not have x free
assume (open_term p x == p);
let ppname = mk_ppname_no_range "_pintrop" in
let k : continuation_elaborator
g (frame * tm_emp)
(push_binding g x ppname_default tm_unit) (tm_pure p * frame) =
continuation_elaborator_with_bind frame d (RU.magic ()) (ppname, x) in
let k : continuation_elaborator
g frame
(push_binding g x ppname_default tm_unit) (frame * tm_pure p) =
k_elab_equiv k (RU.magic ()) (RU.magic ()) in
fun post_hint r ->
let (| t1, c1, d1 |) = r in
let d1 : st_typing g t1 c1 = d1 in
let empty_env = mk_env (fstar_env g) in
assert (equal g (push_env g empty_env));
assert (equal (push_env (push_binding g x ppname_default tm_unit) empty_env)
(push_binding g x ppname_default tm_unit));
let d1 : st_typing (push_binding g x ppname_default tm_unit) t1 c1 =
st_typing_weakening
g
empty_env
t1 c1 d1
(push_binding g x ppname_default tm_unit) in
k post_hint (| t1, c1, d1 |)
module R = FStar.Reflection.V2
// let is_eq2 (t:R.term) : option (R.term & R.term) =
// let head, args = R.collect_app_ln t in
// match R.inspect_ln head, args with
// | R.Tv_FVar fv, [_; (a1, _); (a2, _)]
// | R.Tv_UInst fv _, [_; (a1, _); (a2, _)] ->
// let l = R.inspect_fv fv in
// if l = ["Pulse"; "Steel"; "Wrapper"; "eq2_prop"] ||
// l = ["Prims"; "eq2"]
// then Some (a1, a2)
// else None
// | _ -> None
let pure_uv_heuristic_t =
uvs:env -> t:term ->
T.Tac (option (uv:var { uv `Set.mem` freevars t } & term))
let is_eq2_uvar
: pure_uv_heuristic_t
= fun (uvs:env) (t:term) ->
match is_eq2 t with
| None -> None
| Some (_, l, r) ->
match is_var l with
| Some nm ->
if Set.mem nm.nm_index (dom uvs)
then Some (| nm.nm_index, r |)
else None
| None ->
match is_var r with
| Some nm ->
if Set.mem nm.nm_index (dom uvs)
then Some (| nm.nm_index, l |)
else None
| _ -> None | {
"checked_file": "/",
"dependencies": [
"Pulse.Typing.Metatheory.fsti.checked",
"Pulse.Typing.Combinators.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.fst.checked",
"Pulse.RuntimeUtils.fsti.checked",
"Pulse.PP.fst.checked",
"Pulse.Checker.VPropEquiv.fsti.checked",
"Pulse.Checker.Pure.fsti.checked",
"Pulse.Checker.Prover.Util.fsti.checked",
"Pulse.Checker.Prover.Substs.fsti.checked",
"Pulse.Checker.Prover.Base.fsti.checked",
"Pulse.Checker.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.Formula.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Range.fsti.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Pulse.Checker.Prover.IntroPure.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.V2.Formula",
"short_module": "RF"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "Pulse.Checker.Prover.Substs",
"short_module": "PS"
},
{
"abbrev": true,
"full_module": "Pulse.Syntax.Printer",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Pulse.RuntimeUtils",
"short_module": "RU"
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.VPropEquiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing.Metatheory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: FStar.Stubs.Reflection.Types.term -> FStar.Pervasives.Native.option Pulse.Syntax.Base.nm | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.term",
"FStar.Stubs.Reflection.V2.Builtins.inspect_ln",
"FStar.Stubs.Reflection.Types.namedv",
"FStar.Pervasives.Native.Some",
"Pulse.Syntax.Base.nm",
"Pulse.Syntax.Base.Mknm",
"FStar.Stubs.Reflection.V2.Data.__proj__Mknamedv_view__item__uniq",
"Pulse.Syntax.Base.mk_ppname",
"FStar.Stubs.Reflection.V2.Data.__proj__Mknamedv_view__item__ppname",
"FStar.Stubs.Reflection.V2.Builtins.range_of_term",
"FStar.Stubs.Reflection.V2.Data.namedv_view",
"Prims.precedes",
"FStar.Stubs.Reflection.V2.Builtins.inspect_namedv",
"FStar.Stubs.Reflection.V2.Data.term_view",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option"
] | [] | false | false | false | true | false | let is_host_var (x: R.term) =
| match R.inspect_ln x with
| R.Tv_Var nv ->
let nv_view = R.inspect_namedv nv in
Some ({ nm_index = nv_view.uniq; nm_ppname = mk_ppname (nv_view.ppname) (R.range_of_term x) })
| _ -> None | false |
|
Pulse.Checker.Prover.IntroPure.fst | Pulse.Checker.Prover.IntroPure.pure_uv_heuristic_t | val pure_uv_heuristic_t : Type0 | let pure_uv_heuristic_t =
uvs:env -> t:term ->
T.Tac (option (uv:var { uv `Set.mem` freevars t } & term)) | {
"file_name": "lib/steel/pulse/Pulse.Checker.Prover.IntroPure.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 60,
"end_line": 93,
"start_col": 0,
"start_line": 91
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Pulse.Checker.Prover.IntroPure
open Pulse.Syntax
open Pulse.Typing
open Pulse.Typing.Combinators
open Pulse.Typing.Metatheory
open Pulse.Checker.Pure
open Pulse.Checker.VPropEquiv
open Pulse.Checker.Prover.Base
open Pulse.Checker.Base
open Pulse.Checker.Prover.Util
module RU = Pulse.RuntimeUtils
module T = FStar.Tactics.V2
module P = Pulse.Syntax.Printer
module PS = Pulse.Checker.Prover.Substs
let coerce_eq (#a #b:Type) (x:a) (_:squash (a == b)) : y:b{y == x} = x
let k_intro_pure (g:env) (p:term)
(d:tot_typing g p tm_prop)
(token:prop_validity g p) (frame:vprop)
: T.Tac (continuation_elaborator g frame g (frame * tm_pure p)) =
let t = wtag (Some STT_Ghost) (Tm_IntroPure {p}) in
let c = comp_intro_pure p in
let d : st_typing g t c = T_IntroPure g p d token in
let x = fresh g in
// p is well-typed in g, so it does not have x free
assume (open_term p x == p);
let ppname = mk_ppname_no_range "_pintrop" in
let k : continuation_elaborator
g (frame * tm_emp)
(push_binding g x ppname_default tm_unit) (tm_pure p * frame) =
continuation_elaborator_with_bind frame d (RU.magic ()) (ppname, x) in
let k : continuation_elaborator
g frame
(push_binding g x ppname_default tm_unit) (frame * tm_pure p) =
k_elab_equiv k (RU.magic ()) (RU.magic ()) in
fun post_hint r ->
let (| t1, c1, d1 |) = r in
let d1 : st_typing g t1 c1 = d1 in
let empty_env = mk_env (fstar_env g) in
assert (equal g (push_env g empty_env));
assert (equal (push_env (push_binding g x ppname_default tm_unit) empty_env)
(push_binding g x ppname_default tm_unit));
let d1 : st_typing (push_binding g x ppname_default tm_unit) t1 c1 =
st_typing_weakening
g
empty_env
t1 c1 d1
(push_binding g x ppname_default tm_unit) in
k post_hint (| t1, c1, d1 |)
module R = FStar.Reflection.V2
// let is_eq2 (t:R.term) : option (R.term & R.term) =
// let head, args = R.collect_app_ln t in
// match R.inspect_ln head, args with
// | R.Tv_FVar fv, [_; (a1, _); (a2, _)]
// | R.Tv_UInst fv _, [_; (a1, _); (a2, _)] ->
// let l = R.inspect_fv fv in
// if l = ["Pulse"; "Steel"; "Wrapper"; "eq2_prop"] ||
// l = ["Prims"; "eq2"]
// then Some (a1, a2)
// else None
// | _ -> None | {
"checked_file": "/",
"dependencies": [
"Pulse.Typing.Metatheory.fsti.checked",
"Pulse.Typing.Combinators.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.fst.checked",
"Pulse.RuntimeUtils.fsti.checked",
"Pulse.PP.fst.checked",
"Pulse.Checker.VPropEquiv.fsti.checked",
"Pulse.Checker.Pure.fsti.checked",
"Pulse.Checker.Prover.Util.fsti.checked",
"Pulse.Checker.Prover.Substs.fsti.checked",
"Pulse.Checker.Prover.Base.fsti.checked",
"Pulse.Checker.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.Formula.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Range.fsti.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Pulse.Checker.Prover.IntroPure.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "Pulse.Checker.Prover.Substs",
"short_module": "PS"
},
{
"abbrev": true,
"full_module": "Pulse.Syntax.Printer",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Pulse.RuntimeUtils",
"short_module": "RU"
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.VPropEquiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing.Metatheory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"Pulse.Typing.Env.env",
"Pulse.Syntax.Base.term",
"FStar.Pervasives.Native.option",
"Prims.dtuple2",
"Pulse.Syntax.Base.var",
"Prims.b2t",
"FStar.Set.mem",
"Pulse.Syntax.Naming.freevars"
] | [] | false | false | false | true | true | let pure_uv_heuristic_t =
| uvs: env -> t: term -> T.Tac (option (uv: var{uv `Set.mem` (freevars t)} & term)) | false |
|
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Load128_word4_buffer_index | val va_wp_Load128_word4_buffer_index
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Load128_word4_buffer_index
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Load128_word4_buffer_index (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ offset =!= 0 /\
Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b
index /\ Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b
(va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16
`op_Multiply` index /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr
dst va_x_dst va_s0 in va_get_ok va_sM /\ (let buf = Vale.PPC64LE.Decls.buffer128_read b index
(va_eval_heaplet va_sM h) in l_and (l_and (l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf)
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 74,
"end_line": 1161,
"start_col": 0,
"start_line": 1142
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Xxmrghd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
(va_QProc (va_code_Xxmrghd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2))
//--
//-- Vsel
val va_code_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
sel:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> sel:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsel : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> sel:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsel dst src1 src2 sel) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_is_src_vec_opr sel
va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_is_src_vec_opr sel va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) ==> va_k va_sM (())))
val va_wpProof_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> sel:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsel dst src1 src2 sel va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsel dst src1 src2 sel)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) : (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) =
(va_QProc (va_code_Vsel dst src1 src2 sel) ([va_mod_vec_opr dst]) (va_wp_Vsel dst src1 src2 sel)
(va_wpProof_Vsel dst src1 src2 sel))
//--
//-- Vspltw
val va_code_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot va_code
val va_codegen_success_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot
va_pbool
val va_lemma_Vspltw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> uim:nat2
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltw dst src uim) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltw dst src uim va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltw dst src uim) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) : (va_quickCode
unit (va_code_Vspltw dst src uim)) =
(va_QProc (va_code_Vspltw dst src uim) ([va_mod_vec_opr dst]) (va_wp_Vspltw dst src uim)
(va_wpProof_Vspltw dst src uim))
//--
//-- Vspltisw
val va_code_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisw dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat32 = Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltisw (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat32 =
Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==> va_k va_sM (())))
val va_wpProof_Vspltisw : dst:va_operand_vec_opr -> src:sim -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltisw dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltisw dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltisw (dst:va_operand_vec_opr) (src:sim) : (va_quickCode unit (va_code_Vspltisw dst
src)) =
(va_QProc (va_code_Vspltisw dst src) ([va_mod_vec_opr dst]) (va_wp_Vspltisw dst src)
(va_wpProof_Vspltisw dst src))
//--
//-- Vspltisb
val va_code_Vspltisb : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisb : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisb : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisb dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat8 = Vale.PPC64LE.Machine_s.int_to_nat8 src in let src_nat32 =
Vale.Def.Types_s.be_bytes_to_nat32 (Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8
(Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)) in
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32
src_nat32 src_nat32 src_nat32) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltisb (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat8 =
Vale.PPC64LE.Machine_s.int_to_nat8 src in let src_nat32 = Vale.Def.Types_s.be_bytes_to_nat32
(Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8 (Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)) in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==>
va_k va_sM (())))
val va_wpProof_Vspltisb : dst:va_operand_vec_opr -> src:sim -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltisb dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltisb dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltisb (dst:va_operand_vec_opr) (src:sim) : (va_quickCode unit (va_code_Vspltisb dst
src)) =
(va_QProc (va_code_Vspltisb dst src) ([va_mod_vec_opr dst]) (va_wp_Vspltisb dst src)
(va_wpProof_Vspltisb dst src))
//--
//-- Load128_buffer
val va_code_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_buffer h dst base offset t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) false /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM
h) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr) (base:va_operand_reg_opr)
(offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) false /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall (va_x_dst:va_value_vec_opr) .
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr
va_sM dst == Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) ==> va_k va_sM
(())))
val va_wpProof_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_buffer h dst base offset t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load128_buffer h dst base offset t)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_Load128_buffer h dst base offset t)) =
(va_QProc (va_code_Load128_buffer h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_buffer h dst base offset t b index) (va_wpProof_Load128_buffer h dst base offset
t b index))
//--
//-- Store128_buffer
val va_code_Store128_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Store128_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
src:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Store128_buffer h src base offset t) va_s0 /\
va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_dst_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) true /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_heaplet va_sM h == buffer128_write b index (va_eval_vec_opr va_s0 src) (va_eval_heaplet
va_s0 h) /\ va_state_eq va_sM (va_update_mem va_sM (va_update_ok va_sM
(va_update_operand_heaplet h va_sM va_s0)))))
[@ va_qattr]
let va_wp_Store128_buffer (h:va_operand_heaplet) (src:va_operand_vec_opr) (base:va_operand_reg_opr)
(offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_dst_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) true /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall (va_x_h:va_value_heaplet)
(va_x_mem:vale_heap) . let va_sM = va_upd_mem va_x_mem (va_upd_operand_heaplet h va_x_h va_s0)
in va_get_ok va_sM /\ va_eval_heaplet va_sM h == buffer128_write b index (va_eval_vec_opr va_s0
src) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Store128_buffer h src base offset t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Store128_buffer h src base offset t)
([va_Mod_mem; va_mod_heaplet h]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Store128_buffer (h:va_operand_heaplet) (src:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_Store128_buffer h src base offset t)) =
(va_QProc (va_code_Store128_buffer h src base offset t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_buffer h src base offset t b index) (va_wpProof_Store128_buffer h src base
offset t b index))
//--
//-- Load128_word4_buffer
val va_code_Load128_word4_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_word4_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_word4_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_vec_opr -> base:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_word4_buffer h dst base t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let buf = Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) in l_and (l_and
(l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf) (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Load128_word4_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let buf = Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM
h) in l_and (l_and (l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM
dst) == Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf)
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) ==> va_k va_sM (())))
val va_wpProof_Load128_word4_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_word4_buffer h dst base t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load128_word4_buffer h dst base t)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Load128_word4_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) : (va_quickCode unit
(va_code_Load128_word4_buffer h dst base t)) =
(va_QProc (va_code_Load128_word4_buffer h dst base t) ([va_mod_vec_opr dst])
(va_wp_Load128_word4_buffer h dst base t b index) (va_wpProof_Load128_word4_buffer h dst base t
b index))
//--
//-- Load128_word4_buffer_index
val va_code_Load128_word4_buffer_index : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_word4_buffer_index : h:va_operand_heaplet -> dst:va_operand_vec_opr
-> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_word4_buffer_index : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet
-> dst:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_word4_buffer_index h dst base offset t) va_s0
/\ va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ offset =!= 0 /\
Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b
index /\ Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b
(va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16
`op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let buf = Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) in l_and (l_and
(l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf) (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
base: Vale.PPC64LE.Decls.va_operand_reg_opr ->
offset: Vale.PPC64LE.Decls.va_operand_reg_opr ->
t: Vale.Arch.HeapTypes_s.taint ->
b: Vale.PPC64LE.Memory.buffer128 ->
index: Prims.int ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_heaplet",
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.Arch.HeapTypes_s.taint",
"Vale.PPC64LE.Memory.buffer128",
"Prims.int",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_src_heaplet",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_reg_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_not",
"Prims.eq2",
"Vale.PPC64LE.Decls.valid_src_addr",
"Vale.PPC64LE.Memory.vuint128",
"Vale.PPC64LE.Decls.va_eval_heaplet",
"Vale.PPC64LE.Memory.valid_layout_buffer",
"Vale.PPC64LE.Decls.va_get_mem_layout",
"Vale.PPC64LE.Memory.valid_taint_buf128",
"Vale.Arch.HeapImpl.__proj__Mkvale_heap_layout__item__vl_taint",
"Prims.op_Addition",
"Vale.PPC64LE.Decls.va_eval_reg_opr",
"Vale.PPC64LE.Memory.buffer_addr",
"Prims.op_Multiply",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Types_s.quad32",
"Vale.PPC64LE.Decls.buffer128_read",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Load128_word4_buffer_index
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ offset =!= 0 /\
Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128
b
(va_get_mem_layout va_s0)
(va_eval_heaplet va_s0 h)
false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h)
((va_get_mem_layout va_s0).vl_taint)
t /\
va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) +
16
`op_Multiply`
index /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
(let buf = Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) in
l_and (l_and (l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf)
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) ==>
va_k va_sM (()))) | false |
Pulse.Checker.Prover.IntroPure.fst | Pulse.Checker.Prover.IntroPure.coerce_eq | val coerce_eq: #a: Type -> #b: Type -> x: a -> squash (a == b) -> y: b{y == x} | val coerce_eq: #a: Type -> #b: Type -> x: a -> squash (a == b) -> y: b{y == x} | let coerce_eq (#a #b:Type) (x:a) (_:squash (a == b)) : y:b{y == x} = x | {
"file_name": "lib/steel/pulse/Pulse.Checker.Prover.IntroPure.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 70,
"end_line": 33,
"start_col": 0,
"start_line": 33
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Pulse.Checker.Prover.IntroPure
open Pulse.Syntax
open Pulse.Typing
open Pulse.Typing.Combinators
open Pulse.Typing.Metatheory
open Pulse.Checker.Pure
open Pulse.Checker.VPropEquiv
open Pulse.Checker.Prover.Base
open Pulse.Checker.Base
open Pulse.Checker.Prover.Util
module RU = Pulse.RuntimeUtils
module T = FStar.Tactics.V2
module P = Pulse.Syntax.Printer
module PS = Pulse.Checker.Prover.Substs | {
"checked_file": "/",
"dependencies": [
"Pulse.Typing.Metatheory.fsti.checked",
"Pulse.Typing.Combinators.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.fst.checked",
"Pulse.RuntimeUtils.fsti.checked",
"Pulse.PP.fst.checked",
"Pulse.Checker.VPropEquiv.fsti.checked",
"Pulse.Checker.Pure.fsti.checked",
"Pulse.Checker.Prover.Util.fsti.checked",
"Pulse.Checker.Prover.Substs.fsti.checked",
"Pulse.Checker.Prover.Base.fsti.checked",
"Pulse.Checker.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.Formula.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Range.fsti.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Pulse.Checker.Prover.IntroPure.fst"
} | [
{
"abbrev": true,
"full_module": "Pulse.Checker.Prover.Substs",
"short_module": "PS"
},
{
"abbrev": true,
"full_module": "Pulse.Syntax.Printer",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Pulse.RuntimeUtils",
"short_module": "RU"
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.VPropEquiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing.Metatheory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: a -> _: Prims.squash (a == b) -> y: b{y == x} | Prims.Tot | [
"total"
] | [] | [
"Prims.squash",
"Prims.eq2"
] | [] | false | false | false | false | false | let coerce_eq (#a: Type) (#b: Type) (x: a) (_: squash (a == b)) : y: b{y == x} =
| x | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.buffer128_write | val buffer128_write (b: buffer128) (i: int) (v: quad32) (h: vale_heap)
: Ghost vale_heap (requires buffer_readable h b /\ buffer_writeable b) (ensures fun _ -> True) | val buffer128_write (b: buffer128) (i: int) (v: quad32) (h: vale_heap)
: Ghost vale_heap (requires buffer_readable h b /\ buffer_writeable b) (ensures fun _ -> True) | let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 27,
"start_col": 0,
"start_line": 23
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: Vale.PPC64LE.Memory.buffer128 ->
i: Prims.int ->
v: Vale.PPC64LE.Memory.quad32 ->
h: Vale.PPC64LE.Memory.vale_heap
-> Prims.Ghost Vale.PPC64LE.Memory.vale_heap | Prims.Ghost | [] | [] | [
"Vale.PPC64LE.Memory.buffer128",
"Prims.int",
"Vale.PPC64LE.Memory.quad32",
"Vale.PPC64LE.Memory.vale_heap",
"Vale.PPC64LE.Memory.buffer_write",
"Vale.PPC64LE.Memory.vuint128",
"Prims.l_and",
"Vale.PPC64LE.Memory.buffer_readable",
"Vale.PPC64LE.Memory.buffer_writeable",
"Prims.l_True"
] | [] | false | false | false | false | false | let buffer128_write (b: buffer128) (i: int) (v: quad32) (h: vale_heap)
: Ghost vale_heap (requires buffer_readable h b /\ buffer_writeable b) (ensures fun _ -> True) =
| buffer_write b i v h | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Vmr | val va_quick_Vmr (dst src: va_operand_vec_opr) : (va_quickCode unit (va_code_Vmr dst src)) | val va_quick_Vmr (dst src: va_operand_vec_opr) : (va_quickCode unit (va_code_Vmr dst src)) | let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 59,
"start_col": 0,
"start_line": 56
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.PPC64LE.Decls.va_operand_vec_opr -> src: Vale.PPC64LE.Decls.va_operand_vec_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit (Vale.PPC64LE.InsVector.va_code_Vmr dst src) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vmr",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vmr",
"Vale.PPC64LE.InsVector.va_wpProof_Vmr",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Vmr (dst src: va_operand_vec_opr) : (va_quickCode unit (va_code_Vmr dst src)) =
| (va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst src)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Mfvsrld | val va_quick_Mfvsrld (dst: va_operand_reg_opr) (src: va_operand_vec_opr)
: (va_quickCode unit (va_code_Mfvsrld dst src)) | val va_quick_Mfvsrld (dst: va_operand_reg_opr) (src: va_operand_vec_opr)
: (va_quickCode unit (va_code_Mfvsrld dst src)) | let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 33,
"end_line": 127,
"start_col": 0,
"start_line": 124
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.PPC64LE.Decls.va_operand_reg_opr -> src: Vale.PPC64LE.Decls.va_operand_vec_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit (Vale.PPC64LE.InsVector.va_code_Mfvsrld dst src) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Mfvsrld",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_reg_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Mfvsrld",
"Vale.PPC64LE.InsVector.va_wpProof_Mfvsrld",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Mfvsrld (dst: va_operand_reg_opr) (src: va_operand_vec_opr)
: (va_quickCode unit (va_code_Mfvsrld dst src)) =
| (va_QProc (va_code_Mfvsrld dst src)
([va_mod_reg_opr dst])
(va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Mtvsrdd | val va_wp_Mtvsrdd
(dst: va_operand_vec_opr)
(src1 src2: va_operand_reg_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Mtvsrdd
(dst: va_operand_vec_opr)
(src1 src2: va_operand_reg_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 100,
"end_line": 169,
"start_col": 0,
"start_line": 155
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_reg_opr ->
src2: Vale.PPC64LE.Decls.va_operand_reg_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_reg_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"Vale.PPC64LE.Decls.va_mul_nat",
"Vale.PPC64LE.Machine_s.pow2_32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.PPC64LE.Decls.va_eval_reg_opr",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Words_s.four",
"Vale.Def.Words.Four_s.two_two_to_four",
"Vale.Def.Words_s.Mktwo",
"Vale.Def.Words_s.two",
"Prims.op_Modulus",
"Prims.op_Division",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Mtvsrdd
(dst: va_operand_vec_opr)
(src1 src2: va_operand_reg_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src1 /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\
va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.Mktwo #(Vale.Def.Words_s.two Vale.Def.Types_s.nat32)
(Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
((va_eval_reg_opr va_s0 src2) `op_Modulus` pow2_32)
((va_eval_reg_opr va_s0 src2) `op_Division` pow2_32))
(Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
((va_eval_reg_opr va_s0 src1) `op_Modulus` pow2_32)
((va_eval_reg_opr va_s0 src1) `op_Division` pow2_32))) ==>
va_k va_sM (()))) | false |
Pulse.Checker.Prover.IntroPure.fst | Pulse.Checker.Prover.IntroPure.pure_uvar_heursitics | val pure_uvar_heursitics:pure_uv_heuristic_t | val pure_uvar_heursitics:pure_uv_heuristic_t | let pure_uvar_heursitics : pure_uv_heuristic_t
= let h = [is_eq2_uvar; is_uvar_implication] in
fun (uvs:env) (t:term) ->
let rec loop (h:list pure_uv_heuristic_t)
: T.Tac (option (uv:var { uv `Set.mem` freevars t } & term)) =
match h with
| [] -> None
| h::hs ->
match h uvs t with
| None -> loop hs
| Some (| uv, e |) -> Some (| uv, e |)
in loop h | {
"file_name": "lib/steel/pulse/Pulse.Checker.Prover.IntroPure.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 15,
"end_line": 180,
"start_col": 0,
"start_line": 169
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Pulse.Checker.Prover.IntroPure
open Pulse.Syntax
open Pulse.Typing
open Pulse.Typing.Combinators
open Pulse.Typing.Metatheory
open Pulse.Checker.Pure
open Pulse.Checker.VPropEquiv
open Pulse.Checker.Prover.Base
open Pulse.Checker.Base
open Pulse.Checker.Prover.Util
module RU = Pulse.RuntimeUtils
module T = FStar.Tactics.V2
module P = Pulse.Syntax.Printer
module PS = Pulse.Checker.Prover.Substs
let coerce_eq (#a #b:Type) (x:a) (_:squash (a == b)) : y:b{y == x} = x
let k_intro_pure (g:env) (p:term)
(d:tot_typing g p tm_prop)
(token:prop_validity g p) (frame:vprop)
: T.Tac (continuation_elaborator g frame g (frame * tm_pure p)) =
let t = wtag (Some STT_Ghost) (Tm_IntroPure {p}) in
let c = comp_intro_pure p in
let d : st_typing g t c = T_IntroPure g p d token in
let x = fresh g in
// p is well-typed in g, so it does not have x free
assume (open_term p x == p);
let ppname = mk_ppname_no_range "_pintrop" in
let k : continuation_elaborator
g (frame * tm_emp)
(push_binding g x ppname_default tm_unit) (tm_pure p * frame) =
continuation_elaborator_with_bind frame d (RU.magic ()) (ppname, x) in
let k : continuation_elaborator
g frame
(push_binding g x ppname_default tm_unit) (frame * tm_pure p) =
k_elab_equiv k (RU.magic ()) (RU.magic ()) in
fun post_hint r ->
let (| t1, c1, d1 |) = r in
let d1 : st_typing g t1 c1 = d1 in
let empty_env = mk_env (fstar_env g) in
assert (equal g (push_env g empty_env));
assert (equal (push_env (push_binding g x ppname_default tm_unit) empty_env)
(push_binding g x ppname_default tm_unit));
let d1 : st_typing (push_binding g x ppname_default tm_unit) t1 c1 =
st_typing_weakening
g
empty_env
t1 c1 d1
(push_binding g x ppname_default tm_unit) in
k post_hint (| t1, c1, d1 |)
module R = FStar.Reflection.V2
// let is_eq2 (t:R.term) : option (R.term & R.term) =
// let head, args = R.collect_app_ln t in
// match R.inspect_ln head, args with
// | R.Tv_FVar fv, [_; (a1, _); (a2, _)]
// | R.Tv_UInst fv _, [_; (a1, _); (a2, _)] ->
// let l = R.inspect_fv fv in
// if l = ["Pulse"; "Steel"; "Wrapper"; "eq2_prop"] ||
// l = ["Prims"; "eq2"]
// then Some (a1, a2)
// else None
// | _ -> None
let pure_uv_heuristic_t =
uvs:env -> t:term ->
T.Tac (option (uv:var { uv `Set.mem` freevars t } & term))
let is_eq2_uvar
: pure_uv_heuristic_t
= fun (uvs:env) (t:term) ->
match is_eq2 t with
| None -> None
| Some (_, l, r) ->
match is_var l with
| Some nm ->
if Set.mem nm.nm_index (dom uvs)
then Some (| nm.nm_index, r |)
else None
| None ->
match is_var r with
| Some nm ->
if Set.mem nm.nm_index (dom uvs)
then Some (| nm.nm_index, l |)
else None
| _ -> None
module RF = FStar.Reflection.V2.Formula
let is_host_var (x:R.term) =
match R.inspect_ln x with
| R.Tv_Var nv ->
let nv_view = R.inspect_namedv nv in
Some {nm_index=nv_view.uniq;
nm_ppname=mk_ppname (nv_view.ppname) (R.range_of_term x)}
| _ -> None
let is_uvar_implication
: pure_uv_heuristic_t
= fun (uvs:env) (t:term) ->
debug uvs (fun _ -> Printf.sprintf "is_uvar_implication??: %s\n" (P.term_to_string t));
match t.t with
| Tm_FStar tt -> (
let f = RF.term_as_formula' tt in
match f with
| RF.Implies t0 t1 -> (
debug uvs (fun _ -> Printf.sprintf "is_uvar_implication, LHS=: %s\n" (T.term_to_string t0));
match R.inspect_ln t0 with
| R.Tv_Unknown -> None
| _ -> (
let t0 = tm_fstar t0 FStar.Range.range_0 in
match is_eq2 t0 with
| None -> None
| Some (ty, lhs, rhs) ->
if eq_tm ty (tm_fstar (`bool) FStar.Range.range_0)
then (
let try_negated maybe_var other_side
: T.Tac (option (uv:var { uv `Set.mem` freevars t } & term))
= match is_var lhs with
| None -> None
| Some nm ->
if Set.mem nm.nm_index (dom uvs)
then (
match rhs.t with
| Tm_FStar rhs ->
let rhs = tm_fstar (`(not (`#(rhs)))) FStar.Range.range_0 in
assume (nm.nm_index `Set.mem` freevars t);
Some (| nm.nm_index, rhs |)
| _ -> None
)
else None
in
match try_negated lhs rhs with
| None -> try_negated rhs lhs
| x -> x
)
else None
)
)
| _ -> None
)
| _ -> None | {
"checked_file": "/",
"dependencies": [
"Pulse.Typing.Metatheory.fsti.checked",
"Pulse.Typing.Combinators.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.fst.checked",
"Pulse.RuntimeUtils.fsti.checked",
"Pulse.PP.fst.checked",
"Pulse.Checker.VPropEquiv.fsti.checked",
"Pulse.Checker.Pure.fsti.checked",
"Pulse.Checker.Prover.Util.fsti.checked",
"Pulse.Checker.Prover.Substs.fsti.checked",
"Pulse.Checker.Prover.Base.fsti.checked",
"Pulse.Checker.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.Formula.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Range.fsti.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Pulse.Checker.Prover.IntroPure.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.V2.Formula",
"short_module": "RF"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "Pulse.Checker.Prover.Substs",
"short_module": "PS"
},
{
"abbrev": true,
"full_module": "Pulse.Syntax.Printer",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Pulse.RuntimeUtils",
"short_module": "RU"
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.VPropEquiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing.Metatheory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Pulse.Checker.Prover.IntroPure.pure_uv_heuristic_t | Prims.Tot | [
"total"
] | [] | [
"Pulse.Typing.Env.env",
"Pulse.Syntax.Base.term",
"FStar.Pervasives.Native.option",
"Prims.dtuple2",
"Pulse.Syntax.Base.var",
"Prims.b2t",
"FStar.Set.mem",
"Pulse.Syntax.Naming.freevars",
"Prims.list",
"Pulse.Checker.Prover.IntroPure.pure_uv_heuristic_t",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.Some",
"Prims.Mkdtuple2",
"Prims.Cons",
"Pulse.Checker.Prover.IntroPure.is_eq2_uvar",
"Pulse.Checker.Prover.IntroPure.is_uvar_implication",
"Prims.Nil"
] | [] | false | false | false | true | false | let pure_uvar_heursitics:pure_uv_heuristic_t =
| let h = [is_eq2_uvar; is_uvar_implication] in
fun (uvs: env) (t: term) ->
let rec loop (h: list pure_uv_heuristic_t)
: T.Tac (option (uv: var{uv `Set.mem` (freevars t)} & term)) =
match h with
| [] -> None
| h :: hs ->
match h uvs t with
| None -> loop hs
| Some (| uv , e |) -> Some (| uv, e |)
in
loop h | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Mtvsrws | val va_quick_Mtvsrws (dst: va_operand_vec_opr) (src: va_operand_reg_opr)
: (va_quickCode unit (va_code_Mtvsrws dst src)) | val va_quick_Mtvsrws (dst: va_operand_vec_opr) (src: va_operand_reg_opr)
: (va_quickCode unit (va_code_Mtvsrws dst src)) | let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 33,
"end_line": 224,
"start_col": 0,
"start_line": 221
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.PPC64LE.Decls.va_operand_vec_opr -> src: Vale.PPC64LE.Decls.va_operand_reg_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit (Vale.PPC64LE.InsVector.va_code_Mtvsrws dst src) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Mtvsrws",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Mtvsrws",
"Vale.PPC64LE.InsVector.va_wpProof_Mtvsrws",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Mtvsrws (dst: va_operand_vec_opr) (src: va_operand_reg_opr)
: (va_quickCode unit (va_code_Mtvsrws dst src)) =
| (va_QProc (va_code_Mtvsrws dst src)
([va_mod_vec_opr dst])
(va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Vadduwm | val va_quick_Vadduwm (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vadduwm dst src1 src2)) | val va_quick_Vadduwm (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vadduwm dst src1 src2)) | let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 262,
"start_col": 0,
"start_line": 259
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Vadduwm dst src1 src2) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vadduwm",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vadduwm",
"Vale.PPC64LE.InsVector.va_wpProof_Vadduwm",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Vadduwm (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
| (va_QProc (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Mfvsrd | val va_quick_Mfvsrd (dst: va_operand_reg_opr) (src: va_operand_vec_opr)
: (va_quickCode unit (va_code_Mfvsrd dst src)) | val va_quick_Mfvsrd (dst: va_operand_reg_opr) (src: va_operand_vec_opr)
: (va_quickCode unit (va_code_Mfvsrd dst src)) | let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 93,
"start_col": 0,
"start_line": 90
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.PPC64LE.Decls.va_operand_reg_opr -> src: Vale.PPC64LE.Decls.va_operand_vec_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit (Vale.PPC64LE.InsVector.va_code_Mfvsrd dst src) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Mfvsrd",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_reg_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Mfvsrd",
"Vale.PPC64LE.InsVector.va_wpProof_Mfvsrd",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Mfvsrd (dst: va_operand_reg_opr) (src: va_operand_vec_opr)
: (va_quickCode unit (va_code_Mfvsrd dst src)) =
| (va_QProc (va_code_Mfvsrd dst src)
([va_mod_reg_opr dst])
(va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Vxor | val va_quick_Vxor (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vxor dst src1 src2)) | val va_quick_Vxor (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vxor dst src1 src2)) | let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 299,
"start_col": 0,
"start_line": 296
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Vxor dst src1 src2) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vxor",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vxor",
"Vale.PPC64LE.InsVector.va_wpProof_Vxor",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Vxor (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vxor dst src1 src2)) =
| (va_QProc (va_code_Vxor dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Load128_byte16_buffer | val va_wp_Load128_byte16_buffer
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Load128_byte16_buffer
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Load128_byte16_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 95,
"end_line": 1344,
"start_col": 0,
"start_line": 1332
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Xxmrghd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
(va_QProc (va_code_Xxmrghd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2))
//--
//-- Vsel
val va_code_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
sel:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> sel:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsel : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> sel:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsel dst src1 src2 sel) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_is_src_vec_opr sel
va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_is_src_vec_opr sel va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) ==> va_k va_sM (())))
val va_wpProof_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> sel:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsel dst src1 src2 sel va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsel dst src1 src2 sel)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) : (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) =
(va_QProc (va_code_Vsel dst src1 src2 sel) ([va_mod_vec_opr dst]) (va_wp_Vsel dst src1 src2 sel)
(va_wpProof_Vsel dst src1 src2 sel))
//--
//-- Vspltw
val va_code_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot va_code
val va_codegen_success_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot
va_pbool
val va_lemma_Vspltw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> uim:nat2
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltw dst src uim) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltw dst src uim va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltw dst src uim) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) : (va_quickCode
unit (va_code_Vspltw dst src uim)) =
(va_QProc (va_code_Vspltw dst src uim) ([va_mod_vec_opr dst]) (va_wp_Vspltw dst src uim)
(va_wpProof_Vspltw dst src uim))
//--
//-- Vspltisw
val va_code_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisw dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat32 = Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltisw (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat32 =
Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==> va_k va_sM (())))
val va_wpProof_Vspltisw : dst:va_operand_vec_opr -> src:sim -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltisw dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltisw dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltisw (dst:va_operand_vec_opr) (src:sim) : (va_quickCode unit (va_code_Vspltisw dst
src)) =
(va_QProc (va_code_Vspltisw dst src) ([va_mod_vec_opr dst]) (va_wp_Vspltisw dst src)
(va_wpProof_Vspltisw dst src))
//--
//-- Vspltisb
val va_code_Vspltisb : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisb : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisb : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisb dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat8 = Vale.PPC64LE.Machine_s.int_to_nat8 src in let src_nat32 =
Vale.Def.Types_s.be_bytes_to_nat32 (Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8
(Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)) in
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32
src_nat32 src_nat32 src_nat32) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltisb (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat8 =
Vale.PPC64LE.Machine_s.int_to_nat8 src in let src_nat32 = Vale.Def.Types_s.be_bytes_to_nat32
(Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8 (Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)) in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==>
va_k va_sM (())))
val va_wpProof_Vspltisb : dst:va_operand_vec_opr -> src:sim -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltisb dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltisb dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltisb (dst:va_operand_vec_opr) (src:sim) : (va_quickCode unit (va_code_Vspltisb dst
src)) =
(va_QProc (va_code_Vspltisb dst src) ([va_mod_vec_opr dst]) (va_wp_Vspltisb dst src)
(va_wpProof_Vspltisb dst src))
//--
//-- Load128_buffer
val va_code_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_buffer h dst base offset t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) false /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM
h) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr) (base:va_operand_reg_opr)
(offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) false /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall (va_x_dst:va_value_vec_opr) .
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr
va_sM dst == Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) ==> va_k va_sM
(())))
val va_wpProof_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_buffer h dst base offset t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load128_buffer h dst base offset t)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_Load128_buffer h dst base offset t)) =
(va_QProc (va_code_Load128_buffer h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_buffer h dst base offset t b index) (va_wpProof_Load128_buffer h dst base offset
t b index))
//--
//-- Store128_buffer
val va_code_Store128_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Store128_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
src:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Store128_buffer h src base offset t) va_s0 /\
va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_dst_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) true /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_heaplet va_sM h == buffer128_write b index (va_eval_vec_opr va_s0 src) (va_eval_heaplet
va_s0 h) /\ va_state_eq va_sM (va_update_mem va_sM (va_update_ok va_sM
(va_update_operand_heaplet h va_sM va_s0)))))
[@ va_qattr]
let va_wp_Store128_buffer (h:va_operand_heaplet) (src:va_operand_vec_opr) (base:va_operand_reg_opr)
(offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_dst_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) true /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall (va_x_h:va_value_heaplet)
(va_x_mem:vale_heap) . let va_sM = va_upd_mem va_x_mem (va_upd_operand_heaplet h va_x_h va_s0)
in va_get_ok va_sM /\ va_eval_heaplet va_sM h == buffer128_write b index (va_eval_vec_opr va_s0
src) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Store128_buffer h src base offset t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Store128_buffer h src base offset t)
([va_Mod_mem; va_mod_heaplet h]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Store128_buffer (h:va_operand_heaplet) (src:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_Store128_buffer h src base offset t)) =
(va_QProc (va_code_Store128_buffer h src base offset t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_buffer h src base offset t b index) (va_wpProof_Store128_buffer h src base
offset t b index))
//--
//-- Load128_word4_buffer
val va_code_Load128_word4_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_word4_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_word4_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_vec_opr -> base:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_word4_buffer h dst base t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let buf = Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) in l_and (l_and
(l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf) (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Load128_word4_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let buf = Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM
h) in l_and (l_and (l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM
dst) == Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf)
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) ==> va_k va_sM (())))
val va_wpProof_Load128_word4_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_word4_buffer h dst base t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load128_word4_buffer h dst base t)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Load128_word4_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) : (va_quickCode unit
(va_code_Load128_word4_buffer h dst base t)) =
(va_QProc (va_code_Load128_word4_buffer h dst base t) ([va_mod_vec_opr dst])
(va_wp_Load128_word4_buffer h dst base t b index) (va_wpProof_Load128_word4_buffer h dst base t
b index))
//--
//-- Load128_word4_buffer_index
val va_code_Load128_word4_buffer_index : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_word4_buffer_index : h:va_operand_heaplet -> dst:va_operand_vec_opr
-> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_word4_buffer_index : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet
-> dst:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_word4_buffer_index h dst base offset t) va_s0
/\ va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ offset =!= 0 /\
Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b
index /\ Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b
(va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16
`op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let buf = Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) in l_and (l_and
(l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf) (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Load128_word4_buffer_index (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ offset =!= 0 /\
Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b
index /\ Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b
(va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16
`op_Multiply` index /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr
dst va_x_dst va_s0 in va_get_ok va_sM /\ (let buf = Vale.PPC64LE.Decls.buffer128_read b index
(va_eval_heaplet va_sM h) in l_and (l_and (l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf)
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) ==> va_k va_sM (())))
val va_wpProof_Load128_word4_buffer_index : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_word4_buffer_index h dst base offset t b index
va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load128_word4_buffer_index h dst base
offset t) ([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Load128_word4_buffer_index (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_Load128_word4_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_word4_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_word4_buffer_index h dst base offset t b index)
(va_wpProof_Load128_word4_buffer_index h dst base offset t b index))
//--
//-- Store128_word4_buffer
val va_code_Store128_word4_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Store128_word4_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_word4_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
src:va_operand_vec_opr -> base:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Store128_word4_buffer h src base t) va_s0 /\
va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_dst_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) true /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_heaplet va_sM h == buffer128_write b index (Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) (va_eval_heaplet
va_s0 h) /\ va_state_eq va_sM (va_update_mem va_sM (va_update_ok va_sM
(va_update_operand_heaplet h va_sM va_s0)))))
[@ va_qattr]
let va_wp_Store128_word4_buffer (h:va_operand_heaplet) (src:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_dst_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) true /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall
(va_x_h:va_value_heaplet) (va_x_mem:vale_heap) . let va_sM = va_upd_mem va_x_mem
(va_upd_operand_heaplet h va_x_h va_s0) in va_get_ok va_sM /\ va_eval_heaplet va_sM h ==
buffer128_write b index (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) (va_eval_heaplet
va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_word4_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Store128_word4_buffer h src base t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Store128_word4_buffer h src base t)
([va_Mod_mem; va_mod_heaplet h]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Store128_word4_buffer (h:va_operand_heaplet) (src:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) : (va_quickCode unit
(va_code_Store128_word4_buffer h src base t)) =
(va_QProc (va_code_Store128_word4_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_word4_buffer h src base t b index) (va_wpProof_Store128_word4_buffer h src base
t b index))
//--
//-- Store128_word4_buffer_index
val va_code_Store128_word4_buffer_index : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Store128_word4_buffer_index : h:va_operand_heaplet -> src:va_operand_vec_opr
-> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_word4_buffer_index : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet
-> src:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Store128_word4_buffer_index h src base offset t) va_s0
/\ va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ offset =!= 0 /\
Vale.PPC64LE.Decls.valid_dst_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b
index /\ Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b
(va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) true /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16
`op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_heaplet va_sM h == buffer128_write b index (Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) (va_eval_heaplet
va_s0 h) /\ va_state_eq va_sM (va_update_mem va_sM (va_update_ok va_sM
(va_update_operand_heaplet h va_sM va_s0)))))
[@ va_qattr]
let va_wp_Store128_word4_buffer_index (h:va_operand_heaplet) (src:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ offset =!= 0 /\
Vale.PPC64LE.Decls.valid_dst_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b
index /\ Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b
(va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) true /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16
`op_Multiply` index /\ (forall (va_x_h:va_value_heaplet) (va_x_mem:vale_heap) . let va_sM =
va_upd_mem va_x_mem (va_upd_operand_heaplet h va_x_h va_s0) in va_get_ok va_sM /\
va_eval_heaplet va_sM h == buffer128_write b index (Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) (va_eval_heaplet
va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_word4_buffer_index : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Store128_word4_buffer_index h src base offset t b index
va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Store128_word4_buffer_index h src base
offset t) ([va_Mod_mem; va_mod_heaplet h]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Store128_word4_buffer_index (h:va_operand_heaplet) (src:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_Store128_word4_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_word4_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_word4_buffer_index h src base offset t b index)
(va_wpProof_Store128_word4_buffer_index h src base offset t b index))
//--
//-- Load128_byte16_buffer
val va_code_Load128_byte16_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_byte16_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_byte16_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_vec_opr -> base:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_byte16_buffer h dst base t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
base: Vale.PPC64LE.Decls.va_operand_reg_opr ->
t: Vale.Arch.HeapTypes_s.taint ->
b: Vale.PPC64LE.Memory.buffer128 ->
index: Prims.int ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_heaplet",
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.Arch.HeapTypes_s.taint",
"Vale.PPC64LE.Memory.buffer128",
"Prims.int",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_src_heaplet",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_reg_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Vale.PPC64LE.Decls.valid_src_addr",
"Vale.PPC64LE.Memory.vuint128",
"Vale.PPC64LE.Decls.va_eval_heaplet",
"Vale.PPC64LE.Memory.valid_layout_buffer",
"Vale.PPC64LE.Decls.va_get_mem_layout",
"Vale.PPC64LE.Memory.valid_taint_buf128",
"Vale.Arch.HeapImpl.__proj__Mkvale_heap_layout__item__vl_taint",
"Prims.eq2",
"Vale.PPC64LE.Decls.va_eval_reg_opr",
"Prims.op_Addition",
"Vale.PPC64LE.Memory.buffer_addr",
"Prims.op_Multiply",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Vale.Def.Types_s.quad32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.PPC64LE.Decls.buffer128_read",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Load128_byte16_buffer
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\
Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128
b
(va_get_mem_layout va_s0)
(va_eval_heaplet va_s0 h)
false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h)
((va_get_mem_layout va_s0).vl_taint)
t /\
va_eval_reg_opr va_s0 base ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) +
16
`op_Multiply`
index /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_vec_opr va_sM dst ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read b
index
(va_eval_heaplet va_sM h)) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Load128_byte16_buffer_index | val va_wp_Load128_byte16_buffer_index
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Load128_byte16_buffer_index
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Load128_byte16_buffer_index (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ offset =!= 0 /\
Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b
index /\ Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b
(va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16
`op_Multiply` index /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr
dst va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read b index
(va_eval_heaplet va_sM h)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 1402,
"start_col": 0,
"start_line": 1388
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Xxmrghd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
(va_QProc (va_code_Xxmrghd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2))
//--
//-- Vsel
val va_code_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
sel:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> sel:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsel : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> sel:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsel dst src1 src2 sel) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_is_src_vec_opr sel
va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_is_src_vec_opr sel va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) ==> va_k va_sM (())))
val va_wpProof_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> sel:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsel dst src1 src2 sel va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsel dst src1 src2 sel)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) : (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) =
(va_QProc (va_code_Vsel dst src1 src2 sel) ([va_mod_vec_opr dst]) (va_wp_Vsel dst src1 src2 sel)
(va_wpProof_Vsel dst src1 src2 sel))
//--
//-- Vspltw
val va_code_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot va_code
val va_codegen_success_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot
va_pbool
val va_lemma_Vspltw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> uim:nat2
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltw dst src uim) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltw dst src uim va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltw dst src uim) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) : (va_quickCode
unit (va_code_Vspltw dst src uim)) =
(va_QProc (va_code_Vspltw dst src uim) ([va_mod_vec_opr dst]) (va_wp_Vspltw dst src uim)
(va_wpProof_Vspltw dst src uim))
//--
//-- Vspltisw
val va_code_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisw dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat32 = Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltisw (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat32 =
Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==> va_k va_sM (())))
val va_wpProof_Vspltisw : dst:va_operand_vec_opr -> src:sim -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltisw dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltisw dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltisw (dst:va_operand_vec_opr) (src:sim) : (va_quickCode unit (va_code_Vspltisw dst
src)) =
(va_QProc (va_code_Vspltisw dst src) ([va_mod_vec_opr dst]) (va_wp_Vspltisw dst src)
(va_wpProof_Vspltisw dst src))
//--
//-- Vspltisb
val va_code_Vspltisb : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisb : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisb : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisb dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat8 = Vale.PPC64LE.Machine_s.int_to_nat8 src in let src_nat32 =
Vale.Def.Types_s.be_bytes_to_nat32 (Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8
(Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)) in
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32
src_nat32 src_nat32 src_nat32) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltisb (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat8 =
Vale.PPC64LE.Machine_s.int_to_nat8 src in let src_nat32 = Vale.Def.Types_s.be_bytes_to_nat32
(Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8 (Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)) in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==>
va_k va_sM (())))
val va_wpProof_Vspltisb : dst:va_operand_vec_opr -> src:sim -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltisb dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltisb dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltisb (dst:va_operand_vec_opr) (src:sim) : (va_quickCode unit (va_code_Vspltisb dst
src)) =
(va_QProc (va_code_Vspltisb dst src) ([va_mod_vec_opr dst]) (va_wp_Vspltisb dst src)
(va_wpProof_Vspltisb dst src))
//--
//-- Load128_buffer
val va_code_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_buffer h dst base offset t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) false /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM
h) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr) (base:va_operand_reg_opr)
(offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) false /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall (va_x_dst:va_value_vec_opr) .
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr
va_sM dst == Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) ==> va_k va_sM
(())))
val va_wpProof_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_buffer h dst base offset t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load128_buffer h dst base offset t)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_Load128_buffer h dst base offset t)) =
(va_QProc (va_code_Load128_buffer h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_buffer h dst base offset t b index) (va_wpProof_Load128_buffer h dst base offset
t b index))
//--
//-- Store128_buffer
val va_code_Store128_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Store128_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
src:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Store128_buffer h src base offset t) va_s0 /\
va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_dst_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) true /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_heaplet va_sM h == buffer128_write b index (va_eval_vec_opr va_s0 src) (va_eval_heaplet
va_s0 h) /\ va_state_eq va_sM (va_update_mem va_sM (va_update_ok va_sM
(va_update_operand_heaplet h va_sM va_s0)))))
[@ va_qattr]
let va_wp_Store128_buffer (h:va_operand_heaplet) (src:va_operand_vec_opr) (base:va_operand_reg_opr)
(offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_dst_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) true /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall (va_x_h:va_value_heaplet)
(va_x_mem:vale_heap) . let va_sM = va_upd_mem va_x_mem (va_upd_operand_heaplet h va_x_h va_s0)
in va_get_ok va_sM /\ va_eval_heaplet va_sM h == buffer128_write b index (va_eval_vec_opr va_s0
src) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Store128_buffer h src base offset t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Store128_buffer h src base offset t)
([va_Mod_mem; va_mod_heaplet h]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Store128_buffer (h:va_operand_heaplet) (src:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_Store128_buffer h src base offset t)) =
(va_QProc (va_code_Store128_buffer h src base offset t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_buffer h src base offset t b index) (va_wpProof_Store128_buffer h src base
offset t b index))
//--
//-- Load128_word4_buffer
val va_code_Load128_word4_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_word4_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_word4_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_vec_opr -> base:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_word4_buffer h dst base t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let buf = Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) in l_and (l_and
(l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf) (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Load128_word4_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let buf = Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM
h) in l_and (l_and (l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM
dst) == Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf)
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) ==> va_k va_sM (())))
val va_wpProof_Load128_word4_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_word4_buffer h dst base t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load128_word4_buffer h dst base t)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Load128_word4_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) : (va_quickCode unit
(va_code_Load128_word4_buffer h dst base t)) =
(va_QProc (va_code_Load128_word4_buffer h dst base t) ([va_mod_vec_opr dst])
(va_wp_Load128_word4_buffer h dst base t b index) (va_wpProof_Load128_word4_buffer h dst base t
b index))
//--
//-- Load128_word4_buffer_index
val va_code_Load128_word4_buffer_index : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_word4_buffer_index : h:va_operand_heaplet -> dst:va_operand_vec_opr
-> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_word4_buffer_index : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet
-> dst:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_word4_buffer_index h dst base offset t) va_s0
/\ va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ offset =!= 0 /\
Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b
index /\ Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b
(va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16
`op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let buf = Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) in l_and (l_and
(l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf) (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Load128_word4_buffer_index (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ offset =!= 0 /\
Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b
index /\ Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b
(va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16
`op_Multiply` index /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr
dst va_x_dst va_s0 in va_get_ok va_sM /\ (let buf = Vale.PPC64LE.Decls.buffer128_read b index
(va_eval_heaplet va_sM h) in l_and (l_and (l_and (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__hi3 buf)
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__hi2 buf)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2
(va_eval_vec_opr va_sM dst) == Vale.Def.Words_s.__proj__Mkfour__item__lo1 buf))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.Def.Words_s.__proj__Mkfour__item__lo0 buf)) ==> va_k va_sM (())))
val va_wpProof_Load128_word4_buffer_index : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_word4_buffer_index h dst base offset t b index
va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load128_word4_buffer_index h dst base
offset t) ([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Load128_word4_buffer_index (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_Load128_word4_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_word4_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_word4_buffer_index h dst base offset t b index)
(va_wpProof_Load128_word4_buffer_index h dst base offset t b index))
//--
//-- Store128_word4_buffer
val va_code_Store128_word4_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Store128_word4_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_word4_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
src:va_operand_vec_opr -> base:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Store128_word4_buffer h src base t) va_s0 /\
va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_dst_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) true /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_heaplet va_sM h == buffer128_write b index (Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) (va_eval_heaplet
va_s0 h) /\ va_state_eq va_sM (va_update_mem va_sM (va_update_ok va_sM
(va_update_operand_heaplet h va_sM va_s0)))))
[@ va_qattr]
let va_wp_Store128_word4_buffer (h:va_operand_heaplet) (src:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_dst_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) true /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall
(va_x_h:va_value_heaplet) (va_x_mem:vale_heap) . let va_sM = va_upd_mem va_x_mem
(va_upd_operand_heaplet h va_x_h va_s0) in va_get_ok va_sM /\ va_eval_heaplet va_sM h ==
buffer128_write b index (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) (va_eval_heaplet
va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_word4_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Store128_word4_buffer h src base t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Store128_word4_buffer h src base t)
([va_Mod_mem; va_mod_heaplet h]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Store128_word4_buffer (h:va_operand_heaplet) (src:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) : (va_quickCode unit
(va_code_Store128_word4_buffer h src base t)) =
(va_QProc (va_code_Store128_word4_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_word4_buffer h src base t b index) (va_wpProof_Store128_word4_buffer h src base
t b index))
//--
//-- Store128_word4_buffer_index
val va_code_Store128_word4_buffer_index : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Store128_word4_buffer_index : h:va_operand_heaplet -> src:va_operand_vec_opr
-> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_word4_buffer_index : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet
-> src:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Store128_word4_buffer_index h src base offset t) va_s0
/\ va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ offset =!= 0 /\
Vale.PPC64LE.Decls.valid_dst_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b
index /\ Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b
(va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) true /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16
`op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_heaplet va_sM h == buffer128_write b index (Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) (va_eval_heaplet
va_s0 h) /\ va_state_eq va_sM (va_update_mem va_sM (va_update_ok va_sM
(va_update_operand_heaplet h va_sM va_s0)))))
[@ va_qattr]
let va_wp_Store128_word4_buffer_index (h:va_operand_heaplet) (src:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_heaplet h va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ offset =!= 0 /\
Vale.PPC64LE.Decls.valid_dst_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b
index /\ Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b
(va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) true /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16
`op_Multiply` index /\ (forall (va_x_h:va_value_heaplet) (va_x_mem:vale_heap) . let va_sM =
va_upd_mem va_x_mem (va_upd_operand_heaplet h va_x_h va_s0) in va_get_ok va_sM /\
va_eval_heaplet va_sM h == buffer128_write b index (Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) (va_eval_heaplet
va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_word4_buffer_index : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Store128_word4_buffer_index h src base offset t b index
va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Store128_word4_buffer_index h src base
offset t) ([va_Mod_mem; va_mod_heaplet h]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Store128_word4_buffer_index (h:va_operand_heaplet) (src:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_Store128_word4_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_word4_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_word4_buffer_index h src base offset t b index)
(va_wpProof_Store128_word4_buffer_index h src base offset t b index))
//--
//-- Load128_byte16_buffer
val va_code_Load128_byte16_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_byte16_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_byte16_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_vec_opr -> base:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_byte16_buffer h dst base t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Load128_byte16_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.PPC64LE.Memory.valid_layout_buffer
#Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h)) ==> va_k va_sM (())))
val va_wpProof_Load128_byte16_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_buffer h dst base t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load128_byte16_buffer h dst base t)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Load128_byte16_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) : (va_quickCode unit
(va_code_Load128_byte16_buffer h dst base t)) =
(va_QProc (va_code_Load128_byte16_buffer h dst base t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer h dst base t b index) (va_wpProof_Load128_byte16_buffer h dst base
t b index))
//--
//-- Load128_byte16_buffer_index
val va_code_Load128_byte16_buffer_index : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_byte16_buffer_index : h:va_operand_heaplet -> dst:va_operand_vec_opr
-> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_byte16_buffer_index : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet
-> dst:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_byte16_buffer_index h dst base offset t) va_s0
/\ va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ offset =!= 0 /\
Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b
index /\ Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b
(va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16
`op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
base: Vale.PPC64LE.Decls.va_operand_reg_opr ->
offset: Vale.PPC64LE.Decls.va_operand_reg_opr ->
t: Vale.Arch.HeapTypes_s.taint ->
b: Vale.PPC64LE.Memory.buffer128 ->
index: Prims.int ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_heaplet",
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.Arch.HeapTypes_s.taint",
"Vale.PPC64LE.Memory.buffer128",
"Prims.int",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_src_heaplet",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_reg_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_not",
"Prims.eq2",
"Vale.PPC64LE.Decls.valid_src_addr",
"Vale.PPC64LE.Memory.vuint128",
"Vale.PPC64LE.Decls.va_eval_heaplet",
"Vale.PPC64LE.Memory.valid_layout_buffer",
"Vale.PPC64LE.Decls.va_get_mem_layout",
"Vale.PPC64LE.Memory.valid_taint_buf128",
"Vale.Arch.HeapImpl.__proj__Mkvale_heap_layout__item__vl_taint",
"Prims.op_Addition",
"Vale.PPC64LE.Decls.va_eval_reg_opr",
"Vale.PPC64LE.Memory.buffer_addr",
"Prims.op_Multiply",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Vale.Def.Types_s.quad32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.PPC64LE.Decls.buffer128_read",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Load128_byte16_buffer_index
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ offset =!= 0 /\
Vale.PPC64LE.Decls.valid_src_addr #Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128
b
(va_get_mem_layout va_s0)
(va_eval_heaplet va_s0 h)
false /\
Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h)
((va_get_mem_layout va_s0).vl_taint)
t /\
va_eval_reg_opr va_s0 base + va_eval_reg_opr va_s0 offset ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 b (va_eval_heaplet va_s0 h) +
16
`op_Multiply`
index /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_vec_opr va_sM dst ==
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read b
index
(va_eval_heaplet va_sM h)) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Vsrw | val va_quick_Vsrw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsrw dst src1 src2)) | val va_quick_Vsrw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsrw dst src1 src2)) | let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 445,
"start_col": 0,
"start_line": 442
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Vsrw dst src1 src2) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vsrw",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vsrw",
"Vale.PPC64LE.InsVector.va_wpProof_Vsrw",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Vsrw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsrw dst src1 src2)) =
| (va_QProc (va_code_Vsrw dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Vand | val va_quick_Vand (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vand dst src1 src2)) | val va_quick_Vand (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vand dst src1 src2)) | let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 339,
"start_col": 0,
"start_line": 336
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Vand dst src1 src2) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vand",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vand",
"Vale.PPC64LE.InsVector.va_wpProof_Vand",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Vand (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vand dst src1 src2)) =
| (va_QProc (va_code_Vand dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Vsldoi | val va_quick_Vsldoi (dst src1 src2: va_operand_vec_opr) (count: quad32bytes)
: (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) | val va_quick_Vsldoi (dst src1 src2: va_operand_vec_opr) (count: quad32bytes)
: (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) | let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 634,
"start_col": 0,
"start_line": 631
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr ->
count: Vale.PPC64LE.Machine_s.quad32bytes
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Vsldoi dst src1 src2 count) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Machine_s.quad32bytes",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vsldoi",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vsldoi",
"Vale.PPC64LE.InsVector.va_wpProof_Vsldoi",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Vsldoi (dst src1 src2: va_operand_vec_opr) (count: quad32bytes)
: (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
| (va_QProc (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst])
(va_wp_Vsldoi dst src1 src2 count)
(va_wpProof_Vsldoi dst src1 src2 count)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Vcmpequw | val va_quick_Vcmpequw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) | val va_quick_Vcmpequw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) | let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 40,
"end_line": 569,
"start_col": 0,
"start_line": 566
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Vcmpequw dst src1 src2) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vcmpequw",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vcmpequw",
"Vale.PPC64LE.InsVector.va_wpProof_Vcmpequw",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Vcmpequw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
| (va_QProc (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Mtvsrdd | val va_quick_Mtvsrdd (dst: va_operand_vec_opr) (src1 src2: va_operand_reg_opr)
: (va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) | val va_quick_Mtvsrdd (dst: va_operand_vec_opr) (src1 src2: va_operand_reg_opr)
: (va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) | let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 181,
"start_col": 0,
"start_line": 178
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_reg_opr ->
src2: Vale.PPC64LE.Decls.va_operand_reg_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Mtvsrdd dst src1 src2) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Mtvsrdd",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Mtvsrdd",
"Vale.PPC64LE.InsVector.va_wpProof_Mtvsrdd",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Mtvsrdd (dst: va_operand_vec_opr) (src1 src2: va_operand_reg_opr)
: (va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
| (va_QProc (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Vsel | val va_quick_Vsel (dst src1 src2 sel: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) | val va_quick_Vsel (dst src1 src2 sel: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) | let va_quick_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) : (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) =
(va_QProc (va_code_Vsel dst src1 src2 sel) ([va_mod_vec_opr dst]) (va_wp_Vsel dst src1 src2 sel)
(va_wpProof_Vsel dst src1 src2 sel)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 40,
"end_line": 787,
"start_col": 0,
"start_line": 784
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Xxmrghd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
(va_QProc (va_code_Xxmrghd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2))
//--
//-- Vsel
val va_code_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
sel:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> sel:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsel : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> sel:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsel dst src1 src2 sel) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_is_src_vec_opr sel
va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_is_src_vec_opr sel va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) ==> va_k va_sM (())))
val va_wpProof_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> sel:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsel dst src1 src2 sel va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsel dst src1 src2 sel)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr ->
sel: Vale.PPC64LE.Decls.va_operand_vec_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Vsel dst src1 src2 sel) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vsel",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vsel",
"Vale.PPC64LE.InsVector.va_wpProof_Vsel",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Vsel (dst src1 src2 sel: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) =
| (va_QProc (va_code_Vsel dst src1 src2 sel)
([va_mod_vec_opr dst])
(va_wp_Vsel dst src1 src2 sel)
(va_wpProof_Vsel dst src1 src2 sel)) | false |
LowStar.RVector.fst | LowStar.RVector.rs_elems_inv | val rs_elems_inv:
#a:Type0 -> #rst:Type -> rg:regional rst a ->
h:HS.mem -> rs:S.seq a ->
i:nat -> j:nat{i <= j && j <= S.length rs} ->
GTot Type0 | val rs_elems_inv:
#a:Type0 -> #rst:Type -> rg:regional rst a ->
h:HS.mem -> rs:S.seq a ->
i:nat -> j:nat{i <= j && j <= S.length rs} ->
GTot Type0 | let rs_elems_inv #a #rst rg h rs i j =
V.forall_seq rs i j (rg_inv rg h) | {
"file_name": "ulib/LowStar.RVector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 77,
"start_col": 0,
"start_line": 76
} | (*
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.RVector
open FStar.Classical
open FStar.Integers
open LowStar.Modifies
open LowStar.Regional
open LowStar.Vector
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module S = FStar.Seq
module B = LowStar.Buffer
module V = LowStar.Vector
module U32 = FStar.UInt32
/// Utilities
/// A `regional` type `a` is also `copyable` when there exists a copy operator
/// that guarantees the same representation between `src` and `dst`.
/// For instance, the `copy` operation for `B.buffer a` is `B.blit`.
///
/// Here, no reference at run-time is kept to the state argument of the
/// regional; conceivably, the caller will already have some reference handy to
/// the instance of the regional class and can retrieve the parameter from
/// there.
inline_for_extraction
noeq type copyable (#rst:Type) (a:Type0) (rg:regional rst a) =
| Cpy:
copy: (s:rst{s==Rgl?.state rg} -> src:a -> dst:a ->
HST.ST unit
(requires (fun h0 ->
rg_inv rg h0 src /\ rg_inv rg h0 dst /\
HS.disjoint (Rgl?.region_of rg src)
(Rgl?.region_of rg dst)))
(ensures (fun h0 _ h1 ->
modifies (loc_all_regions_from
false (Rgl?.region_of rg dst)) h0 h1 /\
rg_inv rg h1 dst /\
Rgl?.r_repr rg h1 dst == Rgl?.r_repr rg h0 src))) ->
copyable a rg
// rst: regional state
type rvector (#a:Type0) (#rst:Type) (rg:regional rst a) = V.vector a
val loc_rvector:
#a:Type0 -> #rst:Type -> #rg:regional rst a -> rv:rvector rg -> GTot loc
let loc_rvector #a #rst #rg rv =
loc_all_regions_from false (V.frameOf rv)
/// The invariant of `rvector`
// Here we will define the invariant for `rvector #a` that contains
// the invariant for each element and some more about the vector itself.
val rs_elems_inv:
#a:Type0 -> #rst:Type -> rg:regional rst a ->
h:HS.mem -> rs:S.seq a ->
i:nat -> j:nat{i <= j && j <= S.length rs} -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Vector.fst.checked",
"LowStar.Regional.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.RVector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Vector",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Vector",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Regional",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
rg: LowStar.Regional.regional rst a ->
h: FStar.Monotonic.HyperStack.mem ->
rs: FStar.Seq.Base.seq a ->
i: FStar.Integers.nat ->
j: FStar.Integers.nat{i <= j && j <= FStar.Seq.Base.length rs}
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Regional.regional",
"FStar.Monotonic.HyperStack.mem",
"FStar.Seq.Base.seq",
"FStar.Integers.nat",
"Prims.b2t",
"Prims.op_AmpAmp",
"FStar.Integers.op_Less_Equals",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"FStar.Seq.Base.length",
"LowStar.Vector.forall_seq",
"LowStar.Regional.rg_inv"
] | [] | false | false | false | false | true | let rs_elems_inv #a #rst rg h rs i j =
| V.forall_seq rs i j (rg_inv rg h) | false |
LowStar.RVector.fst | LowStar.RVector.rs_elems_reg | val rs_elems_reg:
#a:Type0 -> #rst:Type -> rg:regional rst a ->
rs:S.seq a -> prid:HS.rid ->
i:nat -> j:nat{i <= j && j <= S.length rs} ->
GTot Type0 | val rs_elems_reg:
#a:Type0 -> #rst:Type -> rg:regional rst a ->
rs:S.seq a -> prid:HS.rid ->
i:nat -> j:nat{i <= j && j <= S.length rs} ->
GTot Type0 | let rs_elems_reg #a #rst rg rs prid i j =
V.forall_seq rs i j
(fun v -> HS.extends (Rgl?.region_of rg v) prid) /\
V.forall2_seq rs i j
(fun v1 v2 -> HS.disjoint (Rgl?.region_of rg v1)
(Rgl?.region_of rg v2)) | {
"file_name": "ulib/LowStar.RVector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 104,
"start_col": 0,
"start_line": 99
} | (*
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.RVector
open FStar.Classical
open FStar.Integers
open LowStar.Modifies
open LowStar.Regional
open LowStar.Vector
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module S = FStar.Seq
module B = LowStar.Buffer
module V = LowStar.Vector
module U32 = FStar.UInt32
/// Utilities
/// A `regional` type `a` is also `copyable` when there exists a copy operator
/// that guarantees the same representation between `src` and `dst`.
/// For instance, the `copy` operation for `B.buffer a` is `B.blit`.
///
/// Here, no reference at run-time is kept to the state argument of the
/// regional; conceivably, the caller will already have some reference handy to
/// the instance of the regional class and can retrieve the parameter from
/// there.
inline_for_extraction
noeq type copyable (#rst:Type) (a:Type0) (rg:regional rst a) =
| Cpy:
copy: (s:rst{s==Rgl?.state rg} -> src:a -> dst:a ->
HST.ST unit
(requires (fun h0 ->
rg_inv rg h0 src /\ rg_inv rg h0 dst /\
HS.disjoint (Rgl?.region_of rg src)
(Rgl?.region_of rg dst)))
(ensures (fun h0 _ h1 ->
modifies (loc_all_regions_from
false (Rgl?.region_of rg dst)) h0 h1 /\
rg_inv rg h1 dst /\
Rgl?.r_repr rg h1 dst == Rgl?.r_repr rg h0 src))) ->
copyable a rg
// rst: regional state
type rvector (#a:Type0) (#rst:Type) (rg:regional rst a) = V.vector a
val loc_rvector:
#a:Type0 -> #rst:Type -> #rg:regional rst a -> rv:rvector rg -> GTot loc
let loc_rvector #a #rst #rg rv =
loc_all_regions_from false (V.frameOf rv)
/// The invariant of `rvector`
// Here we will define the invariant for `rvector #a` that contains
// the invariant for each element and some more about the vector itself.
val rs_elems_inv:
#a:Type0 -> #rst:Type -> rg:regional rst a ->
h:HS.mem -> rs:S.seq a ->
i:nat -> j:nat{i <= j && j <= S.length rs} ->
GTot Type0
let rs_elems_inv #a #rst rg h rs i j =
V.forall_seq rs i j (rg_inv rg h)
val rv_elems_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg ->
i:uint32_t -> j:uint32_t{i <= j && j <= V.size_of rv} ->
GTot Type0
let rv_elems_inv #a #rst #rg h rv i j =
rs_elems_inv rg h (V.as_seq h rv) (U32.v i) (U32.v j)
val elems_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg ->
GTot Type0
let elems_inv #a #rst #rg h rv =
rv_elems_inv h rv 0ul (V.size_of rv)
val rs_elems_reg:
#a:Type0 -> #rst:Type -> rg:regional rst a ->
rs:S.seq a -> prid:HS.rid ->
i:nat -> j:nat{i <= j && j <= S.length rs} -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Vector.fst.checked",
"LowStar.Regional.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.RVector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Vector",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Vector",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Regional",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
rg: LowStar.Regional.regional rst a ->
rs: FStar.Seq.Base.seq a ->
prid: FStar.Monotonic.HyperHeap.rid ->
i: FStar.Integers.nat ->
j: FStar.Integers.nat{i <= j && j <= FStar.Seq.Base.length rs}
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Regional.regional",
"FStar.Seq.Base.seq",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Integers.nat",
"Prims.b2t",
"Prims.op_AmpAmp",
"FStar.Integers.op_Less_Equals",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"FStar.Seq.Base.length",
"Prims.l_and",
"LowStar.Vector.forall_seq",
"FStar.Monotonic.HyperHeap.extends",
"LowStar.Regional.__proj__Rgl__item__region_of",
"LowStar.Vector.forall2_seq",
"FStar.Monotonic.HyperHeap.disjoint"
] | [] | false | false | false | false | true | let rs_elems_reg #a #rst rg rs prid i j =
| V.forall_seq rs i j (fun v -> HS.extends (Rgl?.region_of rg v) prid) /\
V.forall2_seq rs i j (fun v1 v2 -> HS.disjoint (Rgl?.region_of rg v1) (Rgl?.region_of rg v2)) | false |
LowStar.RVector.fst | LowStar.RVector.loc_rvector | val loc_rvector:
#a:Type0 -> #rst:Type -> #rg:regional rst a -> rv:rvector rg -> GTot loc | val loc_rvector:
#a:Type0 -> #rst:Type -> #rg:regional rst a -> rv:rvector rg -> GTot loc | let loc_rvector #a #rst #rg rv =
loc_all_regions_from false (V.frameOf rv) | {
"file_name": "ulib/LowStar.RVector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 65,
"start_col": 0,
"start_line": 64
} | (*
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.RVector
open FStar.Classical
open FStar.Integers
open LowStar.Modifies
open LowStar.Regional
open LowStar.Vector
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module S = FStar.Seq
module B = LowStar.Buffer
module V = LowStar.Vector
module U32 = FStar.UInt32
/// Utilities
/// A `regional` type `a` is also `copyable` when there exists a copy operator
/// that guarantees the same representation between `src` and `dst`.
/// For instance, the `copy` operation for `B.buffer a` is `B.blit`.
///
/// Here, no reference at run-time is kept to the state argument of the
/// regional; conceivably, the caller will already have some reference handy to
/// the instance of the regional class and can retrieve the parameter from
/// there.
inline_for_extraction
noeq type copyable (#rst:Type) (a:Type0) (rg:regional rst a) =
| Cpy:
copy: (s:rst{s==Rgl?.state rg} -> src:a -> dst:a ->
HST.ST unit
(requires (fun h0 ->
rg_inv rg h0 src /\ rg_inv rg h0 dst /\
HS.disjoint (Rgl?.region_of rg src)
(Rgl?.region_of rg dst)))
(ensures (fun h0 _ h1 ->
modifies (loc_all_regions_from
false (Rgl?.region_of rg dst)) h0 h1 /\
rg_inv rg h1 dst /\
Rgl?.r_repr rg h1 dst == Rgl?.r_repr rg h0 src))) ->
copyable a rg
// rst: regional state
type rvector (#a:Type0) (#rst:Type) (rg:regional rst a) = V.vector a
val loc_rvector: | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Vector.fst.checked",
"LowStar.Regional.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.RVector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Vector",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Vector",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Regional",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | rv: LowStar.RVector.rvector rg -> Prims.GTot LowStar.Monotonic.Buffer.loc | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Regional.regional",
"LowStar.RVector.rvector",
"LowStar.Monotonic.Buffer.loc_all_regions_from",
"LowStar.Vector.frameOf",
"LowStar.Monotonic.Buffer.loc"
] | [] | false | false | false | false | false | let loc_rvector #a #rst #rg rv =
| loc_all_regions_from false (V.frameOf rv) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Vsl | val va_quick_Vsl (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsl dst src1 src2)) | val va_quick_Vsl (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsl dst src1 src2)) | let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 516,
"start_col": 0,
"start_line": 513
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Vsl dst src1 src2) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vsl",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vsl",
"Vale.PPC64LE.InsVector.va_wpProof_Vsl",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Vsl (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsl dst src1 src2)) =
| (va_QProc (va_code_Vsl dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Vslw | val va_quick_Vslw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vslw dst src1 src2)) | val va_quick_Vslw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vslw dst src1 src2)) | let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 392,
"start_col": 0,
"start_line": 389
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Vslw dst src1 src2) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vslw",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vslw",
"Vale.PPC64LE.InsVector.va_wpProof_Vslw",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Vslw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vslw dst src1 src2)) =
| (va_QProc (va_code_Vslw dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Vsl | val va_wp_Vsl
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vsl
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 74,
"end_line": 504,
"start_col": 0,
"start_line": 482
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Words_s.nat32",
"Vale.Def.Words_s.nat8",
"Prims.logical",
"Vale.PPC64LE.Memory.nat32",
"Vale.PPC64LE.Memory.nat8",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.index",
"Vale.Def.Words.Seq_s.seq4",
"Prims.eq2",
"Vale.Def.Types_s.be_bytes_to_nat32",
"Vale.Def.Types_s.nat32_to_be_bytes",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.quad32_xor",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Words_s.four",
"Vale.Def.Words.Four_s.four_map",
"Vale.Arch.Types.ishr32",
"Prims.op_Subtraction",
"Vale.Arch.Types.ishl32",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Vsl
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\
(let sh =
(FStar.Seq.Base.index #nat8
(Vale.Def.Types_s.nat32_to_be_bytes (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0
src2)))
3)
`op_Modulus`
8
in
let chk =
fun (v: nat32) (sh: nat8) ->
let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in
l_and (l_and (l_and (sh = (FStar.Seq.Base.index #nat8 bytes 3) `op_Modulus` 8)
(sh = (FStar.Seq.Base.index #nat8 bytes 2) `op_Modulus` 8))
(sh = (FStar.Seq.Base.index #nat8 bytes 1) `op_Modulus` 8))
(sh = (FStar.Seq.Base.index #nat8 bytes 0) `op_Modulus` 8)
in
l_and (l_and (l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2
))
sh)
(chk (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh))
(chk (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh))
(chk (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
(let sh =
(FStar.Seq.Base.index #nat8
(Vale.Def.Types_s.nat32_to_be_bytes (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0
src2)))
3)
`op_Modulus`
8
in
let l =
Vale.Def.Words.Four_s.four_map #nat32
#Vale.Def.Words_s.nat32
(fun (i: nat32) -> Vale.Arch.Types.ishl32 i sh)
(va_eval_vec_opr va_s0 src1)
in
let r =
Vale.Def.Words.Four_s.four_map #nat32
#Vale.Def.Words_s.nat32
(fun (i: nat32) -> Vale.Arch.Types.ishr32 i (32 - sh))
(va_eval_vec_opr va_s0 src1)
in
va_eval_vec_opr va_sM dst ==
Vale.Def.Types_s.quad32_xor l
(Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r)
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==>
va_k va_sM (()))) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Vspltw | val va_quick_Vspltw (dst src: va_operand_vec_opr) (uim: nat2)
: (va_quickCode unit (va_code_Vspltw dst src uim)) | val va_quick_Vspltw (dst src: va_operand_vec_opr) (uim: nat2)
: (va_quickCode unit (va_code_Vspltw dst src uim)) | let va_quick_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) : (va_quickCode
unit (va_code_Vspltw dst src uim)) =
(va_QProc (va_code_Vspltw dst src uim) ([va_mod_vec_opr dst]) (va_wp_Vspltw dst src uim)
(va_wpProof_Vspltw dst src uim)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 859,
"start_col": 0,
"start_line": 856
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Xxmrghd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
(va_QProc (va_code_Xxmrghd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2))
//--
//-- Vsel
val va_code_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
sel:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> sel:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsel : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> sel:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsel dst src1 src2 sel) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_is_src_vec_opr sel
va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_is_src_vec_opr sel va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) ==> va_k va_sM (())))
val va_wpProof_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> sel:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsel dst src1 src2 sel va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsel dst src1 src2 sel)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) : (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) =
(va_QProc (va_code_Vsel dst src1 src2 sel) ([va_mod_vec_opr dst]) (va_wp_Vsel dst src1 src2 sel)
(va_wpProof_Vsel dst src1 src2 sel))
//--
//-- Vspltw
val va_code_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot va_code
val va_codegen_success_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot
va_pbool
val va_lemma_Vspltw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> uim:nat2
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltw dst src uim) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltw dst src uim va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltw dst src uim) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src: Vale.PPC64LE.Decls.va_operand_vec_opr ->
uim: Vale.Def.Words_s.nat2
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Vspltw dst src uim) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.Def.Words_s.nat2",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vspltw",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vspltw",
"Vale.PPC64LE.InsVector.va_wpProof_Vspltw",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Vspltw (dst src: va_operand_vec_opr) (uim: nat2)
: (va_quickCode unit (va_code_Vspltw dst src uim)) =
| (va_QProc (va_code_Vspltw dst src uim)
([va_mod_vec_opr dst])
(va_wp_Vspltw dst src uim)
(va_wpProof_Vspltw dst src uim)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Xxmrghd | val va_quick_Xxmrghd (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Xxmrghd dst src1 src2)) | val va_quick_Xxmrghd (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Xxmrghd dst src1 src2)) | let va_quick_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
(va_QProc (va_code_Xxmrghd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 720,
"start_col": 0,
"start_line": 717
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Xxmrghd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Xxmrghd dst src1 src2) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Xxmrghd",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Xxmrghd",
"Vale.PPC64LE.InsVector.va_wpProof_Xxmrghd",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Xxmrghd (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
| (va_QProc (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2)) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_wp_Vcmpequw | val va_wp_Vcmpequw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vcmpequw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 557,
"start_col": 0,
"start_line": 543
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.PPC64LE.Decls.va_is_dst_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.Def.Words_s.Mkfour",
"Vale.PPC64LE.Decls.va_if",
"Prims.int",
"Prims.op_Equality",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Prims.l_not",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | false | false | false | true | true | let va_wp_Vcmpequw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(fun _ -> 4294967295)
(fun _ -> 0))
(va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(fun _ -> 4294967295)
(fun _ -> 0))
(va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(fun _ -> 4294967295)
(fun _ -> 0))
(va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(fun _ -> 4294967295)
(fun _ -> 0)) ==>
va_k va_sM (()))) | false |
Hacl.Spec.Montgomery.Lemmas.fst | Hacl.Spec.Montgomery.Lemmas.lemma_mont_id1 | val lemma_mont_id1: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (a * d % n * r % n == a % n) | val lemma_mont_id1: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (a * d % n * r % n == a % n) | let lemma_mont_id1 n r d a =
calc (==) {
((a * d % n) * r) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * d) r n }
((a * d) * r) % n;
(==) { Math.Lemmas.paren_mul_right a d r }
(a * (d * r)) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r a (d * r) n }
(a * (d * r % n)) % n;
(==) { assert (r * d % n = 1) }
a % n;
};
assert (a * d % n * r % n == a % n) | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 653,
"start_col": 0,
"start_line": 641
} | module Hacl.Spec.Montgomery.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
(**
https://members.loria.fr/PZimmermann/mca/mca-cup-0.5.9.pdf
https://eprint.iacr.org/2011/239.pdf
https://eprint.iacr.org/2017/1057.pdf *)
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val eea_pow2_odd_k_lemma_d: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let d = n * k1 / pow2 (a - 1) in
d % 2 == (if n * k1 % pow2 a < pow2 (a - 1) then 0 else 1)))
let eea_pow2_odd_k_lemma_d a n k1 =
let d = n * k1 / pow2 (a - 1) in
Math.Lemmas.pow2_modulo_division_lemma_1 (n * k1) (a - 1) a;
assert (d % 2 == n * k1 % pow2 a / pow2 (a - 1));
if d % 2 = 0 then begin
Math.Lemmas.small_division_lemma_2 (n * k1 % pow2 a) (pow2 (a - 1));
assert (n * k1 % pow2 a < pow2 (a - 1));
() end
#push-options "--z3rlimit 100"
val eea_pow2_odd_k_lemma: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1)
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
n * k % pow2 a == 1))
let eea_pow2_odd_k_lemma a n k1 =
let d = n * k1 / pow2 (a - 1) in
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
calc (==) {
n * k1;
(==) { Math.Lemmas.euclidean_division_definition (n * k1) (pow2 (a - 1)) }
1 + d * pow2 (a - 1);
(==) { Math.Lemmas.euclidean_division_definition d 2 }
1 + (d / 2 * 2 + d % 2) * pow2 (a - 1);
(==) { Math.Lemmas.distributivity_add_left (d / 2 * 2) (d % 2) (pow2 (a - 1)) }
1 + d / 2 * 2 * pow2 (a - 1) + d % 2 * pow2 (a - 1);
(==) { Math.Lemmas.pow2_plus 1 (a - 1) }
1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1);
};
assert (n * k1 == 1 + d / 2 * pow2 a + d % 2 * pow2 (a - 1));
if n * k1 % pow2 a < pow2 (a - 1) then begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 0);
calc (==) {
n * k % pow2 a;
(==) { }
(1 + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) (d / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a = 1);
() end
else begin
eea_pow2_odd_k_lemma_d a n k1;
assert (d % 2 = 1);
assert (n * k1 == 1 + d / 2 * pow2 a + pow2 (a - 1));
//assert (n * k == 1 + d / 2 * pow2 a + pow2 (a - 1) + n * pow2 (a - 1));
calc (==) {
n * k % pow2 a;
(==) { Math.Lemmas.distributivity_add_right n k1 (pow2 (a - 1)) }
(n * k1 + n * pow2 (a - 1)) % pow2 a;
(==) { }
(1 + pow2 (a - 1) + n * pow2 (a - 1) + d / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma (1 + pow2 (a - 1) + n * pow2 (a - 1)) (pow2 a) (d / 2) }
(1 + pow2 (a - 1) + n * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.distributivity_add_left 1 n (pow2 (a - 1)) }
(1 + (1 + n) * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.lemma_div_exact (1 + n) 2 }
(1 + (1 + n) / 2 * 2 * pow2 (a - 1)) % pow2 a;
(==) { Math.Lemmas.paren_mul_right ((1 + n) / 2) 2 (pow2 (a - 1)) }
(1 + (1 + n) / 2 * (2 * pow2 (a - 1))) % pow2 a;
(==) { Math.Lemmas.pow2_plus 1 (a - 1)}
(1 + (1 + n) / 2 * pow2 a) % pow2 a;
(==) { Math.Lemmas.modulo_addition_lemma 1 (pow2 a) ((1 + n) / 2) }
1 % pow2 a;
(==) { Math.Lemmas.pow2_le_compat a 1; Math.Lemmas.small_mod 1 (pow2 a) }
1;
};
assert (n * k % pow2 a == 1);
() end
#pop-options
val eea_pow2_odd_k_lemma_bound: a:pos -> n:pos -> k1:pos -> Lemma
(requires n * k1 % pow2 (a - 1) == 1 /\ n % 2 = 1 /\ k1 < pow2 (a - 1))
(ensures (let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
k < pow2 a))
let eea_pow2_odd_k_lemma_bound a n k1 =
if n * k1 % pow2 a < pow2 (a - 1) then
Math.Lemmas.pow2_lt_compat a (a - 1)
else
Math.Lemmas.pow2_double_sum (a - 1)
val eea_pow2_odd_k: a:pos -> n:pos ->
Pure pos
(requires n % 2 = 1)
(ensures fun k ->
n * k % pow2 a == 1 /\ k < pow2 a)
let rec eea_pow2_odd_k a n =
if a = 1 then 1
else begin
let k1 = eea_pow2_odd_k (a - 1) n in
assert (n * k1 % pow2 (a - 1) == 1);
let k = if n * k1 % pow2 a < pow2 (a - 1) then k1 else k1 + pow2 (a - 1) in
eea_pow2_odd_k_lemma a n k1;
eea_pow2_odd_k_lemma_bound a n k1;
assert (n * k % pow2 a == 1);
k end
val eea_pow2_odd: a:pos -> n:pos ->
Pure (tuple2 int int)
(requires n % 2 = 1)
(ensures fun (d, k) ->
pow2 a * d == 1 + k * n /\ - d < n)
let eea_pow2_odd a n =
let k = eea_pow2_odd_k a n in
assert (n * k % pow2 a == 1);
assert (n * k == n * k / pow2 a * pow2 a + 1);
let d = n * k / pow2 a in
Math.Lemmas.lemma_mult_lt_left n k (pow2 a);
assert (n * k < n * pow2 a);
Math.Lemmas.cancel_mul_div n (pow2 a);
assert (d < n);
assert (n * k == d * pow2 a + 1);
(- d, - k)
val mont_preconditions_d: pbits:pos -> rLen:pos -> n:pos{1 < n} -> Lemma
(requires n % 2 = 1)
(ensures (let d, k = eea_pow2_odd (pbits * rLen) n in pow2 (pbits * rLen) * d % n == 1))
let mont_preconditions_d pbits rLen n =
let d, k = eea_pow2_odd (pbits * rLen) n in
calc (==) {
pow2 (pbits * rLen) * d % n;
(==) { }
(1 + k * n) % n;
(==) { Math.Lemmas.modulo_addition_lemma 1 n k }
1 % n;
(==) { Math.Lemmas.small_mod 1 n }
1;
};
assert (pow2 (pbits * rLen) * d % n == 1)
val mont_preconditions_n0: pbits:pos -> n:pos{n > 1} -> mu:nat -> Lemma
(requires (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures (1 + n * mu) % pow2 pbits == 0)
let mont_preconditions_n0 pbits n mu =
calc (==) {
(1 + n * mu) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n * mu) (pow2 pbits) }
(1 + n * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_mul_distr_l n mu (pow2 pbits) }
(1 + n % pow2 pbits * mu % pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.lemma_mod_plus_distr_r 1 (n % pow2 pbits * mu) (pow2 pbits) }
(1 + n % pow2 pbits * mu) % pow2 pbits;
(==) { assert ((1 + (n % pow2 pbits) * mu) % pow2 pbits == 0) }
0;
};
assert ((1 + n * mu) % pow2 pbits == 0)
val mont_preconditions: pbits:pos -> rLen:pos -> n:pos{1 < n} -> mu:nat -> Lemma
(requires
n % 2 = 1 /\ (1 + (n % pow2 pbits) * mu) % pow2 pbits == 0)
(ensures
(let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
r * d % n == 1 /\ (1 + n * mu) % pow2 pbits == 0))
let mont_preconditions pbits rLen n mu =
mont_preconditions_d pbits rLen n;
mont_preconditions_n0 pbits n mu
/// High-level specification of Montgomery arithmetic
val mont_reduction_f: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i < rLen} -> c:nat -> nat
let mont_reduction_f pbits rLen n mu i c =
let c_i = c / pow2 (pbits * i) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
let res = c + n * q_i * pow2 (pbits * i) in
res
val mont_reduction_loop_div_r: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction_loop_div_r pbits rLen n mu c =
let res = repeati rLen (mont_reduction_f pbits rLen n mu) c in
let res = res / pow2 (pbits * rLen) in
res
val mont_reduction: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> nat
let mont_reduction pbits rLen n mu c =
let res = mont_reduction_loop_div_r pbits rLen n mu c in
if res < n then res else res - n
val to_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let to_mont pbits rLen n mu a =
let r2 = pow2 (2 * pbits * rLen) % n in
let c = a * r2 in
mont_reduction pbits rLen n mu c
val from_mont: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> aM:nat -> nat
let from_mont pbits rLen n mu aM =
mont_reduction pbits rLen n mu aM
val mont_mul: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> b:nat -> nat
let mont_mul pbits rLen n mu a b =
let c = a * b in
mont_reduction pbits rLen n mu c
val mont_sqr: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> a:nat -> nat
let mont_sqr pbits rLen n mu a =
mont_mul pbits rLen n mu a a
val mont_one: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> nat
let mont_one pbits rLen n mu =
let r2 = pow2 (2 * pbits * rLen) % n in
mont_reduction pbits rLen n mu r2
/// Lemma (let res = mont_reduction_loop_div_r pbits rLen n mu c in
/// res % n == c * d % n /\ res <= (c - n) / r + n)
val mont_reduction_lemma_step_bound_aux:
pbits:pos -> n:pos -> q_i:nat{q_i < pow2 pbits} -> i:pos -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures res0 + n * q_i * pow2 (pbits * (i - 1)) <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound_aux pbits n q_i i c res0 =
let b = pow2 (pbits * i) in
let b1 = pow2 (pbits * (i - 1)) in
calc (<=) {
res0 + n * q_i * b1;
(<=) { Math.Lemmas.lemma_mult_le_right b1 q_i (pow2 pbits - 1) }
res0 + n * (pow2 pbits - 1) * b1;
(==) { Math.Lemmas.paren_mul_right n (pow2 pbits - 1) b1 }
res0 + n * ((pow2 pbits - 1) * b1);
(==) { Math.Lemmas.distributivity_sub_left (pow2 pbits) 1 b1 }
res0 + n * (pow2 pbits * b1 - b1);
(==) { Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
res0 + n * (b - b1);
(==) { Math.Lemmas.distributivity_sub_right n b b1 }
res0 + n * b - n * b1;
(<=) { }
c + (b1 - 1) * n + n * b - n * b1;
(==) { Math.Lemmas.distributivity_sub_left b1 1 n }
c + b1 * n - n + n * b - n * b1;
(==) { }
c - n + b * n;
(==) { Math.Lemmas.distributivity_sub_left b 1 n }
c + (b - 1) * n;
}
val mont_reduction_lemma_step_bound:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 <= c + (pow2 (pbits * i) - 1) * n)
let mont_reduction_lemma_step_bound pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
mont_reduction_lemma_step_bound_aux pbits n q_i i c res0;
assert (res <= c + (pow2 (pbits * i) - 1) * n)
val mont_reduction_lemma_step_mod_pbits: pbits:pos -> n:pos -> mu:nat -> c_i:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (c_i + n * (mu * c_i % pow2 pbits)) % pow2 pbits == 0)
let mont_reduction_lemma_step_mod_pbits pbits n mu c_i =
let r = pow2 pbits in
let q_i = mu * c_i % r in
calc (==) {
(c_i + n * q_i) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * q_i) r }
(c_i + n * q_i % r) % r;
(==) { }
(c_i + n * (mu * c_i % r) % r) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_r n (mu * c_i) r }
(c_i + n * (mu * c_i) % r) % r;
(==) { Math.Lemmas.lemma_mod_plus_distr_r c_i (n * (mu * c_i)) r }
(c_i + n * (mu * c_i)) % r;
(==) { Math.Lemmas.paren_mul_right n mu c_i }
(c_i + n * mu * c_i) % r;
(==) { Math.Lemmas.distributivity_add_left 1 (n * mu) c_i }
((1 + n * mu) * c_i) % r;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (1 + n * mu) c_i r }
((1 + n * mu) % r * c_i) % r;
(==) { assert ((1 + n * mu) % r = 0) }
0;
}
val mont_reduction_lemma_step_modr_aux: pbits:pos -> n:pos -> q_i:nat -> i:pos -> res0:nat ->
Lemma (let b1 = pow2 (pbits * (i - 1)) in
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i) == (res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1)
let mont_reduction_lemma_step_modr_aux pbits n q_i i res0 =
let b1 = pow2 (pbits * (i - 1)) in
Math.Lemmas.distributivity_sub_right pbits i 1;
assert (pbits * i - pbits * (i - 1) == pbits);
calc (==) {
(res0 / b1 * b1 + n * q_i * b1) % pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (res0 / b1) (n * q_i) b1 }
(res0 / b1 + n * q_i) * b1 % pow2 (pbits * i);
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (res0 / b1 + n * q_i) (pbits * i) (pbits * (i - 1)) }
(res0 / b1 + n * q_i) % pow2 pbits * b1;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (res0 / b1) (n * q_i) (pow2 pbits) }
(res0 / b1 % pow2 pbits + n * q_i) % pow2 pbits * b1;
}
val mont_reduction_lemma_step_modr:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> res0:nat -> Lemma
(requires res0 % pow2 (pbits * (i - 1)) == 0 /\ (1 + n * mu) % pow2 pbits == 0)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % pow2 (pbits * i) == 0)
let mont_reduction_lemma_step_modr pbits rLen n mu i res0 =
let b1 = pow2 (pbits * (i - 1)) in
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / b1 % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
Math.Lemmas.lemma_div_exact res0 b1;
mont_reduction_lemma_step_modr_aux pbits n q_i i res0;
mont_reduction_lemma_step_mod_pbits pbits n mu c_i
val mont_reduction_lemma_step_modn:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires res0 % n == c % n)
(ensures mont_reduction_f pbits rLen n mu (i - 1) res0 % n == c % n)
let mont_reduction_lemma_step_modn pbits rLen n mu i c res0 =
let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
let c_i = res0 / pow2 (pbits * (i - 1)) % pow2 pbits in
let q_i = mu * c_i % pow2 pbits in
assert (res == res0 + n * q_i * pow2 (pbits * (i - 1)));
Math.Lemmas.paren_mul_right n q_i (pow2 (pbits * (i - 1)));
Math.Lemmas.modulo_addition_lemma res0 n (q_i * pow2 (pbits * (i - 1)))
val mont_reduction_lemma_step:
pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:pos{i <= rLen} -> c:nat -> res0:nat -> Lemma
(requires
res0 % n == c % n /\ res0 % pow2 (pbits * (i - 1)) == 0 /\
res0 <= c + (pow2 (pbits * (i - 1)) - 1) * n /\ (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = mont_reduction_f pbits rLen n mu (i - 1) res0 in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let mont_reduction_lemma_step pbits rLen n mu i c res0 =
mont_reduction_lemma_step_bound pbits rLen n mu i c res0;
mont_reduction_lemma_step_modr pbits rLen n mu i res0;
mont_reduction_lemma_step_modn pbits rLen n mu i c res0
val mont_reduction_loop_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> i:nat{i <= rLen} -> c:nat -> Lemma
(requires (1 + n * mu) % pow2 pbits == 0)
(ensures (let res = repeati i (mont_reduction_f pbits rLen n mu) c in
res % n == c % n /\ res % pow2 (pbits * i) == 0 /\ res <= c + (pow2 (pbits * i) - 1) * n))
let rec mont_reduction_loop_lemma pbits rLen n mu i c =
let res : nat = repeati i (mont_reduction_f pbits rLen n mu) c in
if i = 0 then
eq_repeati0 i (mont_reduction_f pbits rLen n mu) c
else begin
unfold_repeati i (mont_reduction_f pbits rLen n mu) c (i - 1);
let res0 : nat = repeati (i - 1) (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu (i - 1) c;
mont_reduction_lemma_step pbits rLen n mu i c res0 end
val mont_reduction_loop_div_r_fits_lemma: pbits:pos -> rLen:nat -> n:pos -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
res <= (c - n) / r + n))
let mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
Math.Lemmas.lemma_div_le res (c + (r - 1) * n) r;
assert (res / r <= (c + (r - 1) * n) / r);
calc (==) {
(c + (r - 1) * n) / r;
(==) { Math.Lemmas.distributivity_sub_left r 1 n }
(c - n + r * n) / r;
(==) { Math.Lemmas.division_addition_lemma (c - n) r n }
(c - n) / r + n;
};
assert (res / r <= (c - n) / r + n)
val mont_reduction_loop_div_r_eval_lemma: pbits:pos -> rLen:nat -> n:pos -> d:int -> mu:nat -> c:nat -> Lemma
(requires (let r = pow2 (pbits * rLen) in
(1 + n * mu) % pow2 pbits == 0 /\ r * d % n == 1))
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
res % n == c * d % n))
let mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c =
let r = pow2 (pbits * rLen) in
let res : nat = repeati rLen (mont_reduction_f pbits rLen n mu) c in
mont_reduction_loop_lemma pbits rLen n mu rLen c;
assert (res % n == c % n /\ res % r == 0 /\ res <= c + (r - 1) * n);
calc (==) {
res / r % n;
(==) { assert (r * d % n == 1) }
res / r * (r * d % n) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (res / r) (r * d) n }
res / r * (r * d) % n;
(==) { Math.Lemmas.paren_mul_right (res / r) r d }
res / r * r * d % n;
(==) { Math.Lemmas.div_exact_r res r }
res * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l res d n }
res % n * d % n;
(==) { assert (res % n == c % n) }
c % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l c d n }
c * d % n;
};
assert (res / r % n == c * d % n)
let mont_pre (pbits:pos) (rLen:pos) (n:pos) (mu:nat) =
(1 + n * mu) % pow2 pbits == 0 /\
1 < n /\ n < pow2 (pbits * rLen) /\ n % 2 = 1
val mont_reduction_loop_div_r_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let res = mont_reduction_loop_div_r pbits rLen n mu c in
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
res % n == c * d % n /\ res <= (c - n) / r + n))
let mont_reduction_loop_div_r_lemma pbits rLen n mu c =
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
mont_reduction_loop_div_r_fits_lemma pbits rLen n mu c;
mont_reduction_loop_div_r_eval_lemma pbits rLen n d mu c
/// Montgomery multiplication
val lemma_fits_c_lt_rn: c:nat -> r:pos -> n:pos -> Lemma
(requires c < r * n)
(ensures (c - n) / r < n)
let lemma_fits_c_lt_rn c r n =
assert (c < r * n);
Math.Lemmas.cancel_mul_div n r;
assert (c / r < n);
Math.Lemmas.lemma_div_le (c - n) c r
val mont_reduction_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> c:nat -> Lemma
(requires
mont_pre pbits rLen n mu /\ c < pow2 (pbits * rLen) * n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_reduction pbits rLen n mu c == c * d % n))
let mont_reduction_lemma pbits rLen n mu c =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_reduction_loop_div_r pbits rLen n mu c in
mont_reduction_loop_div_r_lemma pbits rLen n mu c;
assert (res % n == c * d % n /\ res <= (c - n) / r + n);
let res1 = if res < n then res else res - n in
if res < n then ()
else begin
assert (res1 % n == (res - n) % n);
Math.Lemmas.lemma_mod_sub res n 1;
assert (res1 % n == res % n);
assert (res1 <= (c - n) / r);
lemma_fits_c_lt_rn c r n end;
Math.Lemmas.small_mod res1 n
val mont_mul_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> b:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < n /\ b < n)
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_mul pbits rLen n mu a b == a * b * d % n))
let mont_mul_lemma pbits rLen n mu a b =
let r = pow2 (pbits * rLen) in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let res = mont_mul pbits rLen n mu a b in
Math.Lemmas.lemma_mult_lt_sqr a b n;
assert (a * b < n * n);
Math.Lemmas.lemma_mult_lt_right n n r;
assert (a * b < r * n);
mont_reduction_lemma pbits rLen n mu (a * b)
/// Lemma (to_mont rLen n mu a == a * r % n)
val lemma_mod_mul_distr3: a:int -> b:int -> c:int -> n:pos -> Lemma
(a * (b % n) * c % n == a * b * c % n)
let lemma_mod_mul_distr3 a b c n =
calc (==) {
a * (b % n) * c % n;
(==) { }
(b % n) * a * c % n;
(==) { Math.Lemmas.paren_mul_right (b % n) a c }
(b % n) * (a * c) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l b (a * c) n }
b * (a * c) % n;
(==) { Math.Lemmas.paren_mul_right b a c }
a * b * c % n;
}
val mult_lt_lemma: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a < c /\ b < d)
(ensures a * b < c * d)
let mult_lt_lemma a b c d = ()
val to_mont_eval_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures (let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
a * r2 * d % n == a * r % n))
let to_mont_eval_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
mont_preconditions_d pbits rLen n;
let c = a * r2 in
calc (==) {
c * d % n;
(==) { }
a * r2 * d % n;
(==) { Math.Lemmas.paren_mul_right 2 pbits rLen;
Math.Lemmas.pow2_plus (pbits * rLen) (pbits * rLen) }
a * (r * r % n) * d % n;
(==) { lemma_mod_mul_distr3 a (r * r) d n }
a * (r * r) * d % n;
(==) { Math.Lemmas.paren_mul_right a r r }
a * r * r * d % n;
(==) { Math.Lemmas.paren_mul_right (a * r) r d }
a * r * (r * d) % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (a * r) (r * d) n }
a * r * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a * r % n;
};
assert (c * d % n == a * r % n)
val to_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> a:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ a < pow2 (pbits * rLen))
(ensures to_mont pbits rLen n mu a == a * pow2 (pbits * rLen) % n)
let to_mont_lemma pbits rLen n mu a =
let r = pow2 (pbits * rLen) in
let r2 = pow2 (2 * pbits * rLen) % n in
let d, _ = eea_pow2_odd (pbits * rLen) n in
let c = a * r2 in
let aM = to_mont pbits rLen n mu a in
assert (aM == mont_reduction pbits rLen n mu c);
mult_lt_lemma a r2 r n;
assert (a * r2 < r * n);
mont_reduction_lemma pbits rLen n mu c;
assert (aM == c * d % n);
to_mont_eval_lemma pbits rLen n mu a;
assert (aM == a * r % n)
/// Lemma (from_mont rLen n mu aM == aM * d % n)
val from_mont_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> aM:nat -> Lemma
(requires mont_pre pbits rLen n mu /\ aM < pow2 (pbits * rLen))
(ensures (let d, _ = eea_pow2_odd (pbits * rLen) n in
from_mont pbits rLen n mu aM == aM * d % n))
let from_mont_lemma pbits rLen n mu aM =
mont_reduction_lemma pbits rLen n mu aM
/// Lemma (mont_one pbits rLen n mu == 1 * r % n)
val mont_one_lemma: pbits:pos -> rLen:pos -> n:pos -> mu:nat -> Lemma
(requires mont_pre pbits rLen n mu)
(ensures mont_one pbits rLen n mu == 1 * pow2 (pbits * rLen) % n)
let mont_one_lemma pbits rLen n mu =
to_mont_lemma pbits rLen n mu 1
/// Properties of Montgomery arithmetic
// from_mont (to_mont a) = a % n
val lemma_mont_id: n:pos -> r:pos -> d:int{r * d % n == 1} -> a:nat ->
Lemma (a * r % n * d % n == a % n)
let lemma_mont_id n r d a =
calc (==) {
a * r % n * d % n;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (a * r) d n }
a * r * d % n;
(==) { Math.Lemmas.paren_mul_right a r d; Math.Lemmas.lemma_mod_mul_distr_r a (r * d) n }
a * (r * d % n) % n;
(==) { assert (r * d % n == 1) }
a % n;
}
// to_mont (mont_reduction a) = a % n
val lemma_mont_id1: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Montgomery.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Montgomery",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.pos -> r: Prims.pos -> d: Prims.int{r * d % n = 1} -> a: Prims.nat
-> FStar.Pervasives.Lemma (ensures (a * d % n) * r % n == a % n) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.int",
"Prims.b2t",
"Prims.op_Equality",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Prims.nat",
"Prims._assert",
"Prims.eq2",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.lemma_mod_mul_distr_l",
"Prims.squash",
"FStar.Math.Lemmas.paren_mul_right",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r"
] | [] | false | false | true | false | false | let lemma_mont_id1 n r d a =
| calc ( == ) {
((a * d % n) * r) % n;
( == ) { Math.Lemmas.lemma_mod_mul_distr_l (a * d) r n }
((a * d) * r) % n;
( == ) { Math.Lemmas.paren_mul_right a d r }
(a * (d * r)) % n;
( == ) { Math.Lemmas.lemma_mod_mul_distr_r a (d * r) n }
(a * (d * r % n)) % n;
( == ) { assert (r * d % n = 1) }
a % n;
};
assert ((a * d % n) * r % n == a % n) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Vspltisw | val va_quick_Vspltisw (dst: va_operand_vec_opr) (src: sim)
: (va_quickCode unit (va_code_Vspltisw dst src)) | val va_quick_Vspltisw (dst: va_operand_vec_opr) (src: sim)
: (va_quickCode unit (va_code_Vspltisw dst src)) | let va_quick_Vspltisw (dst:va_operand_vec_opr) (src:sim) : (va_quickCode unit (va_code_Vspltisw dst
src)) =
(va_QProc (va_code_Vspltisw dst src) ([va_mod_vec_opr dst]) (va_wp_Vspltisw dst src)
(va_wpProof_Vspltisw dst src)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 893,
"start_col": 0,
"start_line": 890
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Xxmrghd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
(va_QProc (va_code_Xxmrghd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2))
//--
//-- Vsel
val va_code_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
sel:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> sel:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsel : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> sel:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsel dst src1 src2 sel) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_is_src_vec_opr sel
va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_is_src_vec_opr sel va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) ==> va_k va_sM (())))
val va_wpProof_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> sel:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsel dst src1 src2 sel va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsel dst src1 src2 sel)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) : (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) =
(va_QProc (va_code_Vsel dst src1 src2 sel) ([va_mod_vec_opr dst]) (va_wp_Vsel dst src1 src2 sel)
(va_wpProof_Vsel dst src1 src2 sel))
//--
//-- Vspltw
val va_code_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot va_code
val va_codegen_success_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot
va_pbool
val va_lemma_Vspltw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> uim:nat2
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltw dst src uim) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltw dst src uim va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltw dst src uim) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) : (va_quickCode
unit (va_code_Vspltw dst src uim)) =
(va_QProc (va_code_Vspltw dst src uim) ([va_mod_vec_opr dst]) (va_wp_Vspltw dst src uim)
(va_wpProof_Vspltw dst src uim))
//--
//-- Vspltisw
val va_code_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisw dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat32 = Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltisw (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat32 =
Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==> va_k va_sM (())))
val va_wpProof_Vspltisw : dst:va_operand_vec_opr -> src:sim -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltisw dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltisw dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.PPC64LE.Decls.va_operand_vec_opr -> src: Vale.PPC64LE.Machine_s.sim
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Vspltisw dst src) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Machine_s.sim",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vspltisw",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vspltisw",
"Vale.PPC64LE.InsVector.va_wpProof_Vspltisw",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Vspltisw (dst: va_operand_vec_opr) (src: sim)
: (va_quickCode unit (va_code_Vspltisw dst src)) =
| (va_QProc (va_code_Vspltisw dst src)
([va_mod_vec_opr dst])
(va_wp_Vspltisw dst src)
(va_wpProof_Vspltisw dst src)) | false |
LowStar.RVector.fst | LowStar.RVector.rv_itself_inv | val rv_itself_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg -> GTot Type0 | val rv_itself_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg -> GTot Type0 | let rv_itself_inv #a #rst #rg h rv =
V.live h rv /\ V.freeable rv /\
HST.is_eternal_region (V.frameOf rv) | {
"file_name": "ulib/LowStar.RVector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 126,
"start_col": 0,
"start_line": 124
} | (*
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.RVector
open FStar.Classical
open FStar.Integers
open LowStar.Modifies
open LowStar.Regional
open LowStar.Vector
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module S = FStar.Seq
module B = LowStar.Buffer
module V = LowStar.Vector
module U32 = FStar.UInt32
/// Utilities
/// A `regional` type `a` is also `copyable` when there exists a copy operator
/// that guarantees the same representation between `src` and `dst`.
/// For instance, the `copy` operation for `B.buffer a` is `B.blit`.
///
/// Here, no reference at run-time is kept to the state argument of the
/// regional; conceivably, the caller will already have some reference handy to
/// the instance of the regional class and can retrieve the parameter from
/// there.
inline_for_extraction
noeq type copyable (#rst:Type) (a:Type0) (rg:regional rst a) =
| Cpy:
copy: (s:rst{s==Rgl?.state rg} -> src:a -> dst:a ->
HST.ST unit
(requires (fun h0 ->
rg_inv rg h0 src /\ rg_inv rg h0 dst /\
HS.disjoint (Rgl?.region_of rg src)
(Rgl?.region_of rg dst)))
(ensures (fun h0 _ h1 ->
modifies (loc_all_regions_from
false (Rgl?.region_of rg dst)) h0 h1 /\
rg_inv rg h1 dst /\
Rgl?.r_repr rg h1 dst == Rgl?.r_repr rg h0 src))) ->
copyable a rg
// rst: regional state
type rvector (#a:Type0) (#rst:Type) (rg:regional rst a) = V.vector a
val loc_rvector:
#a:Type0 -> #rst:Type -> #rg:regional rst a -> rv:rvector rg -> GTot loc
let loc_rvector #a #rst #rg rv =
loc_all_regions_from false (V.frameOf rv)
/// The invariant of `rvector`
// Here we will define the invariant for `rvector #a` that contains
// the invariant for each element and some more about the vector itself.
val rs_elems_inv:
#a:Type0 -> #rst:Type -> rg:regional rst a ->
h:HS.mem -> rs:S.seq a ->
i:nat -> j:nat{i <= j && j <= S.length rs} ->
GTot Type0
let rs_elems_inv #a #rst rg h rs i j =
V.forall_seq rs i j (rg_inv rg h)
val rv_elems_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg ->
i:uint32_t -> j:uint32_t{i <= j && j <= V.size_of rv} ->
GTot Type0
let rv_elems_inv #a #rst #rg h rv i j =
rs_elems_inv rg h (V.as_seq h rv) (U32.v i) (U32.v j)
val elems_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg ->
GTot Type0
let elems_inv #a #rst #rg h rv =
rv_elems_inv h rv 0ul (V.size_of rv)
val rs_elems_reg:
#a:Type0 -> #rst:Type -> rg:regional rst a ->
rs:S.seq a -> prid:HS.rid ->
i:nat -> j:nat{i <= j && j <= S.length rs} ->
GTot Type0
let rs_elems_reg #a #rst rg rs prid i j =
V.forall_seq rs i j
(fun v -> HS.extends (Rgl?.region_of rg v) prid) /\
V.forall2_seq rs i j
(fun v1 v2 -> HS.disjoint (Rgl?.region_of rg v1)
(Rgl?.region_of rg v2))
val rv_elems_reg:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg ->
i:uint32_t -> j:uint32_t{i <= j && j <= V.size_of rv} ->
GTot Type0
let rv_elems_reg #a #rst #rg h rv i j =
rs_elems_reg rg (V.as_seq h rv) (V.frameOf rv) (U32.v i) (U32.v j)
val elems_reg:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg ->
GTot Type0
let elems_reg #a #rst #rg h rv =
rv_elems_reg h rv 0ul (V.size_of rv)
val rv_itself_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Vector.fst.checked",
"LowStar.Regional.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.RVector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Vector",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Vector",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Regional",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h: FStar.Monotonic.HyperStack.mem -> rv: LowStar.RVector.rvector rg -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Regional.regional",
"FStar.Monotonic.HyperStack.mem",
"LowStar.RVector.rvector",
"Prims.l_and",
"LowStar.Vector.live",
"LowStar.Vector.freeable",
"FStar.HyperStack.ST.is_eternal_region",
"LowStar.Vector.frameOf"
] | [] | false | false | false | false | true | let rv_itself_inv #a #rst #rg h rv =
| V.live h rv /\ V.freeable rv /\ HST.is_eternal_region (V.frameOf rv) | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Load128_buffer | val va_quick_Load128_buffer
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Load128_buffer h dst base offset t)) | val va_quick_Load128_buffer
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Load128_buffer h dst base offset t)) | let va_quick_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr)
(base:va_operand_reg_opr) (offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_Load128_buffer h dst base offset t)) =
(va_QProc (va_code_Load128_buffer h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_buffer h dst base offset t b index) (va_wpProof_Load128_buffer h dst base offset
t b index)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 988,
"start_col": 0,
"start_line": 983
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2))
//--
//-- Xxmrghd
val va_code_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Xxmrghd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Xxmrghd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Xxmrghd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Xxmrghd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Xxmrghd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Xxmrghd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Xxmrghd dst src1 src2)) =
(va_QProc (va_code_Xxmrghd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Xxmrghd dst src1 src2)
(va_wpProof_Xxmrghd dst src1 src2))
//--
//-- Vsel
val va_code_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
sel:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> sel:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsel : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> sel:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsel dst src1 src2 sel) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_is_src_vec_opr sel
va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_is_src_vec_opr sel va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 sel)) /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst) == Vale.Def.Sel.isel32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 sel)) ==> va_k va_sM (())))
val va_wpProof_Vsel : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> sel:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsel dst src1 src2 sel va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsel dst src1 src2 sel)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsel (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(sel:va_operand_vec_opr) : (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) =
(va_QProc (va_code_Vsel dst src1 src2 sel) ([va_mod_vec_opr dst]) (va_wp_Vsel dst src1 src2 sel)
(va_wpProof_Vsel dst src1 src2 sel))
//--
//-- Vspltw
val va_code_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot va_code
val va_codegen_success_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 -> Tot
va_pbool
val va_lemma_Vspltw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> uim:nat2
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltw dst src uim) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (uim == 0 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src))) /\ (uim == 1 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src))) /\ (uim == 2 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src))) /\ (uim == 3 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vspltw : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> uim:nat2 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltw dst src uim va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltw dst src uim) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltw (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (uim:nat2) : (va_quickCode
unit (va_code_Vspltw dst src uim)) =
(va_QProc (va_code_Vspltw dst src uim) ([va_mod_vec_opr dst]) (va_wp_Vspltw dst src uim)
(va_wpProof_Vspltw dst src uim))
//--
//-- Vspltisw
val va_code_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisw : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisw dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat32 = Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltisw (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat32 =
Vale.PPC64LE.Machine_s.int_to_nat32 src in va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==> va_k va_sM (())))
val va_wpProof_Vspltisw : dst:va_operand_vec_opr -> src:sim -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltisw dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltisw dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltisw (dst:va_operand_vec_opr) (src:sim) : (va_quickCode unit (va_code_Vspltisw dst
src)) =
(va_QProc (va_code_Vspltisw dst src) ([va_mod_vec_opr dst]) (va_wp_Vspltisw dst src)
(va_wpProof_Vspltisw dst src))
//--
//-- Vspltisb
val va_code_Vspltisb : dst:va_operand_vec_opr -> src:sim -> Tot va_code
val va_codegen_success_Vspltisb : dst:va_operand_vec_opr -> src:sim -> Tot va_pbool
val va_lemma_Vspltisb : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr -> src:sim
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vspltisb dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_nat8 = Vale.PPC64LE.Machine_s.int_to_nat8 src in let src_nat32 =
Vale.Def.Types_s.be_bytes_to_nat32 (Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8
(Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)) in
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32
src_nat32 src_nat32 src_nat32) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vspltisb (dst:va_operand_vec_opr) (src:sim) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let
va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ (let src_nat8 =
Vale.PPC64LE.Machine_s.int_to_nat8 src in let src_nat32 = Vale.Def.Types_s.be_bytes_to_nat32
(Vale.Def.Words.Seq_s.four_to_seq_BE #Vale.Def.Types_s.nat8 (Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat8 src_nat8 src_nat8 src_nat8 src_nat8)) in va_eval_vec_opr va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 src_nat32 src_nat32 src_nat32 src_nat32) ==>
va_k va_sM (())))
val va_wpProof_Vspltisb : dst:va_operand_vec_opr -> src:sim -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vspltisb dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vspltisb dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vspltisb (dst:va_operand_vec_opr) (src:sim) : (va_quickCode unit (va_code_Vspltisb dst
src)) =
(va_QProc (va_code_Vspltisb dst src) ([va_mod_vec_opr dst]) (va_wp_Vspltisb dst src)
(va_wpProof_Vspltisb dst src))
//--
//-- Load128_buffer
val va_code_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_code
val va_codegen_success_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Load128_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_vec_opr -> base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_buffer h dst base offset t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) false /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM
h) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_vec_opr) (base:va_operand_reg_opr)
(offset:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr base va_s0 /\
va_is_src_reg_opr offset va_s0 /\ va_get_ok va_s0 /\ Vale.PPC64LE.Decls.valid_src_addr
#Vale.PPC64LE.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.PPC64LE.Memory.valid_layout_buffer #Vale.PPC64LE.Memory.vuint128 b (va_get_mem_layout
va_s0) (va_eval_heaplet va_s0 h) false /\ Vale.PPC64LE.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr va_s0 base
+ va_eval_reg_opr va_s0 offset == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall (va_x_dst:va_value_vec_opr) .
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr
va_sM dst == Vale.PPC64LE.Decls.buffer128_read b index (va_eval_heaplet va_sM h) ==> va_k va_sM
(())))
val va_wpProof_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_vec_opr ->
base:va_operand_reg_opr -> offset:va_operand_reg_opr -> t:taint -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_buffer h dst base offset t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load128_buffer h dst base offset t)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
base: Vale.PPC64LE.Decls.va_operand_reg_opr ->
offset: Vale.PPC64LE.Decls.va_operand_reg_opr ->
t: Vale.Arch.HeapTypes_s.taint ->
b: Vale.PPC64LE.Memory.buffer128 ->
index: Prims.int
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Load128_buffer h dst base offset t) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_heaplet",
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.Arch.HeapTypes_s.taint",
"Vale.PPC64LE.Memory.buffer128",
"Prims.int",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Load128_buffer",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Load128_buffer",
"Vale.PPC64LE.InsVector.va_wpProof_Load128_buffer",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Load128_buffer
(h: va_operand_heaplet)
(dst: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Load128_buffer h dst base offset t)) =
| (va_QProc (va_code_Load128_buffer h dst base offset t)
([va_mod_vec_opr dst])
(va_wp_Load128_buffer h dst base offset t b index)
(va_wpProof_Load128_buffer h dst base offset t b index)) | false |
LowStar.RVector.fst | LowStar.RVector.rv_inv | val rv_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg -> GTot Type0 | val rv_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg -> GTot Type0 | let rv_inv #a #rst #rg h rv =
elems_inv h rv /\
elems_reg h rv /\
rv_itself_inv h rv | {
"file_name": "ulib/LowStar.RVector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 135,
"start_col": 0,
"start_line": 132
} | (*
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.RVector
open FStar.Classical
open FStar.Integers
open LowStar.Modifies
open LowStar.Regional
open LowStar.Vector
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module S = FStar.Seq
module B = LowStar.Buffer
module V = LowStar.Vector
module U32 = FStar.UInt32
/// Utilities
/// A `regional` type `a` is also `copyable` when there exists a copy operator
/// that guarantees the same representation between `src` and `dst`.
/// For instance, the `copy` operation for `B.buffer a` is `B.blit`.
///
/// Here, no reference at run-time is kept to the state argument of the
/// regional; conceivably, the caller will already have some reference handy to
/// the instance of the regional class and can retrieve the parameter from
/// there.
inline_for_extraction
noeq type copyable (#rst:Type) (a:Type0) (rg:regional rst a) =
| Cpy:
copy: (s:rst{s==Rgl?.state rg} -> src:a -> dst:a ->
HST.ST unit
(requires (fun h0 ->
rg_inv rg h0 src /\ rg_inv rg h0 dst /\
HS.disjoint (Rgl?.region_of rg src)
(Rgl?.region_of rg dst)))
(ensures (fun h0 _ h1 ->
modifies (loc_all_regions_from
false (Rgl?.region_of rg dst)) h0 h1 /\
rg_inv rg h1 dst /\
Rgl?.r_repr rg h1 dst == Rgl?.r_repr rg h0 src))) ->
copyable a rg
// rst: regional state
type rvector (#a:Type0) (#rst:Type) (rg:regional rst a) = V.vector a
val loc_rvector:
#a:Type0 -> #rst:Type -> #rg:regional rst a -> rv:rvector rg -> GTot loc
let loc_rvector #a #rst #rg rv =
loc_all_regions_from false (V.frameOf rv)
/// The invariant of `rvector`
// Here we will define the invariant for `rvector #a` that contains
// the invariant for each element and some more about the vector itself.
val rs_elems_inv:
#a:Type0 -> #rst:Type -> rg:regional rst a ->
h:HS.mem -> rs:S.seq a ->
i:nat -> j:nat{i <= j && j <= S.length rs} ->
GTot Type0
let rs_elems_inv #a #rst rg h rs i j =
V.forall_seq rs i j (rg_inv rg h)
val rv_elems_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg ->
i:uint32_t -> j:uint32_t{i <= j && j <= V.size_of rv} ->
GTot Type0
let rv_elems_inv #a #rst #rg h rv i j =
rs_elems_inv rg h (V.as_seq h rv) (U32.v i) (U32.v j)
val elems_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg ->
GTot Type0
let elems_inv #a #rst #rg h rv =
rv_elems_inv h rv 0ul (V.size_of rv)
val rs_elems_reg:
#a:Type0 -> #rst:Type -> rg:regional rst a ->
rs:S.seq a -> prid:HS.rid ->
i:nat -> j:nat{i <= j && j <= S.length rs} ->
GTot Type0
let rs_elems_reg #a #rst rg rs prid i j =
V.forall_seq rs i j
(fun v -> HS.extends (Rgl?.region_of rg v) prid) /\
V.forall2_seq rs i j
(fun v1 v2 -> HS.disjoint (Rgl?.region_of rg v1)
(Rgl?.region_of rg v2))
val rv_elems_reg:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg ->
i:uint32_t -> j:uint32_t{i <= j && j <= V.size_of rv} ->
GTot Type0
let rv_elems_reg #a #rst #rg h rv i j =
rs_elems_reg rg (V.as_seq h rv) (V.frameOf rv) (U32.v i) (U32.v j)
val elems_reg:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg ->
GTot Type0
let elems_reg #a #rst #rg h rv =
rv_elems_reg h rv 0ul (V.size_of rv)
val rv_itself_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg -> GTot Type0
let rv_itself_inv #a #rst #rg h rv =
V.live h rv /\ V.freeable rv /\
HST.is_eternal_region (V.frameOf rv)
// This is the invariant of `rvector`.
val rv_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Vector.fst.checked",
"LowStar.Regional.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.RVector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Vector",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Vector",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Regional",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h: FStar.Monotonic.HyperStack.mem -> rv: LowStar.RVector.rvector rg -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Regional.regional",
"FStar.Monotonic.HyperStack.mem",
"LowStar.RVector.rvector",
"Prims.l_and",
"LowStar.RVector.elems_inv",
"LowStar.RVector.elems_reg",
"LowStar.RVector.rv_itself_inv"
] | [] | false | false | false | false | true | let rv_inv #a #rst #rg h rv =
| elems_inv h rv /\ elems_reg h rv /\ rv_itself_inv h rv | false |
Vale.PPC64LE.InsVector.fsti | Vale.PPC64LE.InsVector.va_quick_Vmrghw | val va_quick_Vmrghw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vmrghw dst src1 src2)) | val va_quick_Vmrghw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vmrghw dst src1 src2)) | let va_quick_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
(va_QProc (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2)) | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 677,
"start_col": 0,
"start_line": 674
} | module Vale.PPC64LE.InsVector
open FStar.Seq
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.Memory
open Vale.Def.Sel
open Spec.SHA2
open Spec.Hash.Definitions
open Vale.SHA.PPC64LE.SHA_helpers
open Vale.AES.AES_BE_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Vmr
val va_code_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmr : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmr dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0 /\
va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == va_eval_vec_opr va_sM src ==> va_k va_sM (())))
val va_wpProof_Vmr : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmr dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmr dst src) ([va_mod_vec_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vmr (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vmr dst src)) =
(va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst
src))
//--
//-- Mfvsrd
val va_code_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrd dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.hi64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrd : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrd (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrd dst src)) =
(va_QProc (va_code_Mfvsrd dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src))
//--
//-- Mfvsrld
val va_code_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Mfvsrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mfvsrld dst src) va_s0 /\ va_is_dst_reg_opr dst va_s0
/\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM src) /\ va_state_eq
va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_reg_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_reg_opr) . let va_sM = va_upd_operand_reg_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ va_eval_reg_opr va_sM dst == Vale.Arch.Types.lo64 (va_eval_vec_opr va_sM
src) ==> va_k va_sM (())))
val va_wpProof_Mfvsrld : dst:va_operand_reg_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mfvsrld dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mfvsrld dst src) ([va_mod_reg_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mfvsrld (dst:va_operand_reg_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Mfvsrld dst src)) =
(va_QProc (va_code_Mfvsrld dst src) ([va_mod_reg_opr dst]) (va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src))
//--
//-- Mtvsrdd
val va_code_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Tot va_code
val va_codegen_success_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_mul_nat pow2_32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM dst)) +
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src1 /\ va_mul_nat pow2_32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst)) + Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src2 /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.two_two_to_four #Vale.Def.Types_s.nat32 (Vale.Def.Words_s.Mktwo
#(Vale.Def.Words_s.two Vale.Def.Types_s.nat32) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32
(va_eval_reg_opr va_s0 src2 `op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src2 `op_Division`
pow2_32)) (Vale.Def.Words_s.Mktwo #Vale.Def.Types_s.nat32 (va_eval_reg_opr va_s0 src1
`op_Modulus` pow2_32) (va_eval_reg_opr va_s0 src1 `op_Division` pow2_32))) ==> va_k va_sM (())))
val va_wpProof_Mtvsrdd : dst:va_operand_vec_opr -> src1:va_operand_reg_opr ->
src2:va_operand_reg_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrdd dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrdd (dst:va_operand_vec_opr) (src1:va_operand_reg_opr) (src2:va_operand_reg_opr) :
(va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) =
(va_QProc (va_code_Mtvsrdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Mtvsrdd dst src1 src2)
(va_wpProof_Mtvsrdd dst src1 src2))
//--
//-- Mtvsrws
val va_code_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_code
val va_codegen_success_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> Tot va_pbool
val va_lemma_Mtvsrws : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mtvsrws dst src) va_s0 /\ va_is_dst_vec_opr dst va_s0
/\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_reg_opr src va_s0 /\ va_get_ok va_s0 /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_sM dst) ==
va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_sM dst) == va_eval_reg_opr va_s0
src `op_Modulus` pow2_32 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_sM
dst) == va_eval_reg_opr va_s0 src `op_Modulus` pow2_32 ==> va_k va_sM (())))
val va_wpProof_Mtvsrws : dst:va_operand_vec_opr -> src:va_operand_reg_opr -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mtvsrws dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mtvsrws dst src) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mtvsrws (dst:va_operand_vec_opr) (src:va_operand_reg_opr) : (va_quickCode unit
(va_code_Mtvsrws dst src)) =
(va_QProc (va_code_Mtvsrws dst src) ([va_mod_vec_opr dst]) (va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src))
//--
//-- Vadduwm
val va_code_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vadduwm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vadduwm dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Arch.Types.add_wrap_quad32 (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vadduwm : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vadduwm dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vadduwm dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vadduwm (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vadduwm dst src1 src2)) =
(va_QProc (va_code_Vadduwm dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vadduwm dst src1 src2)
(va_wpProof_Vadduwm dst src1 src2))
//--
//-- Vxor
val va_code_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vxor dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Types_s.quad32_xor
(va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vxor : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vxor dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vxor (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vxor dst src1 src2)) =
(va_QProc (va_code_Vxor dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vxor dst src1 src2)
(va_wpProof_Vxor dst src1 src2))
//--
//-- Vand
val va_code_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vand dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32
(fun (di:nat32) (si:nat32) -> Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1)
(va_eval_vec_opr va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst ==
Vale.Def.Words.Four_s.four_map2 #nat32 #Vale.Def.Types_s.nat32 (fun (di:nat32) (si:nat32) ->
Vale.Arch.Types.iand32 di si) (va_eval_vec_opr va_s0 src1) (va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (())))
val va_wpProof_Vand : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vand dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vand dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vand (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vand dst src1 src2)) =
(va_QProc (va_code_Vand dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vand dst src1 src2)
(va_wpProof_Vand dst src1 src2))
//--
//-- Vslw
val va_code_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vslw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vslw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishl32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishl32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vslw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vslw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vslw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vslw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vslw dst src1 src2)) =
(va_QProc (va_code_Vslw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vslw dst src1 src2)
(va_wpProof_Vslw dst src1 src2))
//--
//-- Vsrw
val va_code_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsrw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsrw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_vec_opr va_s0 src1)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src2) `op_Modulus` 32)) (Vale.Arch.Types.ishr32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) `op_Modulus` 32))
(Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) (Vale.Arch.Types.ishr32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1)) (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) `op_Modulus`
32)) ==> va_k va_sM (())))
val va_wpProof_Vsrw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsrw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsrw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsrw dst src1 src2)) =
(va_QProc (va_code_Vsrw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsrw dst src1 src2)
(va_wpProof_Vsrw dst src1 src2))
//--
//-- Vsl
val va_code_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr ->
Tot va_code
val va_codegen_success_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsl : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsl dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let chk = fun (v:nat32) (sh:nat8) -> let bytes = Vale.Def.Types_s.nat32_to_be_bytes v in l_and
(l_and (l_and (sh = FStar.Seq.Base.index #nat8 bytes 3 `op_Modulus` 8) (sh =
FStar.Seq.Base.index #nat8 bytes 2 `op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 1
`op_Modulus` 8)) (sh = FStar.Seq.Base.index #nat8 bytes 0 `op_Modulus` 8) in l_and (l_and
(l_and (chk (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) sh) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) sh)) (chk
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) sh)) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (let sh = FStar.Seq.Base.index #nat8 (Vale.Def.Types_s.nat32_to_be_bytes
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2))) 3 `op_Modulus` 8 in
let l = Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishl32 i sh) (va_eval_vec_opr va_s0 src1) in let r =
Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Words_s.nat32 (fun (i:nat32) ->
Vale.Arch.Types.ishr32 i (32 - sh)) (va_eval_vec_opr va_s0 src1) in va_eval_vec_opr va_sM dst
== Vale.Def.Types_s.quad32_xor l (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 r) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 r)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 r))) ==> va_k va_sM (())))
val va_wpProof_Vsl : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsl dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsl dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsl (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vsl dst src1 src2)) =
(va_QProc (va_code_Vsl dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vsl dst src1 src2)
(va_wpProof_Vsl dst src1 src2))
//--
//-- Vcmpequw
val va_code_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcmpequw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vcmpequw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) (if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) then 4294967295 else
0) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2)) (fun _
-> 4294967295) (fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1) = Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0 src2)) (fun _ -> 4294967295) (fun _ -> 0)) (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2)) (fun _ -> 4294967295)
(fun _ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Vcmpequw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vcmpequw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcmpequw dst src1 src2)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vcmpequw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) =
(va_QProc (va_code_Vcmpequw dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcmpequw dst src1 src2)
(va_wpProof_Vcmpequw dst src1 src2))
//--
//-- Vsldoi
val va_code_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> count:quad32bytes -> Tot va_code
val va_codegen_success_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> Tot va_pbool
val va_lemma_Vsldoi : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr -> count:quad32bytes
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vsldoi dst src1 src2 count) va_s0 /\ va_is_dst_vec_opr
dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
(count == 4 \/ count == 8 \/ count == 12)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (count == 4 \/ count == 8 \/ count == 12) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (count == 4 ==> va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1))) /\ (count == 8 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))) /\ (count == 12 ==>
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src1))) ==> va_k va_sM (())))
val va_wpProof_Vsldoi : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> count:quad32bytes -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vsldoi dst src1 src2 count va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsldoi dst src1 src2 count)
([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vsldoi (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(count:quad32bytes) : (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) =
(va_QProc (va_code_Vsldoi dst src1 src2 count) ([va_mod_vec_opr dst]) (va_wp_Vsldoi dst src1 src2
count) (va_wpProof_Vsldoi dst src1 src2 count))
//--
//-- Vmrghw
val va_code_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vmrghw : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Vmrghw dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vmrghw (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\ (forall (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src2)) (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src1)) ==> va_k va_sM (())))
val va_wpProof_Vmrghw : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Vmrghw dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vmrghw dst src1 src2) ([va_mod_vec_opr
dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES_BE_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.InsVector.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src2: Vale.PPC64LE.Decls.va_operand_vec_opr
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Vmrghw dst src1 src2) | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vmrghw",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vmrghw",
"Vale.PPC64LE.InsVector.va_wpProof_Vmrghw",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Vmrghw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vmrghw dst src1 src2)) =
| (va_QProc (va_code_Vmrghw dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Vmrghw dst src1 src2)
(va_wpProof_Vmrghw dst src1 src2)) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.