effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.Pervasives.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)) | [
{
"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
}
] | 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 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 | 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 = | false | null | true | 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);
()) | {
"checked_file": "Hacl.Spec.Montgomery.Lemmas.fst.checked",
"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"
} | [
"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"
] | [] | 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)) | false | false | Hacl.Spec.Montgomery.Lemmas.fst | {
"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"
} | null | 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)) | [] | Hacl.Spec.Montgomery.Lemmas.eea_pow2_odd_k_lemma | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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)) | {
"end_col": 10,
"end_line": 94,
"start_col": 33,
"start_line": 37
} |
FStar.Pervasives.Lemma | val lemma_mont_id1: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (a * d % n * r % n == a % n) | [
{
"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
}
] | 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) | 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 = | false | null | true | 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) | {
"checked_file": "Hacl.Spec.Montgomery.Lemmas.fst.checked",
"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"
} | [
"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"
] | [] | 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) | false | false | Hacl.Spec.Montgomery.Lemmas.fst | {
"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"
} | null | val lemma_mont_id1: n:pos -> r:pos -> d:int{r * d % n = 1} -> a:nat ->
Lemma (a * d % n * r % n == a % n) | [] | Hacl.Spec.Montgomery.Lemmas.lemma_mont_id1 | {
"file_name": "code/bignum/Hacl.Spec.Montgomery.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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) | {
"end_col": 37,
"end_line": 653,
"start_col": 2,
"start_line": 642
} |
FStar.All.ALL | [
{
"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
}
] | false | 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 | let test () = | true | null | false | 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) | {
"checked_file": "Spec.Poly1305.Test.fst.checked",
"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"
} | [] | [
"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"
] | [] | 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 | false | false | Spec.Poly1305.Test.fst | {
"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"
} | null | val test : _: Prims.unit -> FStar.All.ALL Prims.bool | [] | Spec.Poly1305.Test.test | {
"file_name": "specs/tests/Spec.Poly1305.Test.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit -> FStar.All.ALL Prims.bool | {
"end_col": 66,
"end_line": 55,
"start_col": 13,
"start_line": 50
} |
|
Prims.Tot | val expected:lbytes 16 | [
{
"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
}
] | 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 | val expected:lbytes 16
let expected:lbytes 16 = | false | null | false | 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": "Spec.Poly1305.Test.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Spec.Poly1305.Test.fst | {
"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"
} | null | val expected:lbytes 16 | [] | Spec.Poly1305.Test.expected | {
"file_name": "specs/tests/Spec.Poly1305.Test.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 16 | {
"end_col": 11,
"end_line": 47,
"start_col": 26,
"start_line": 41
} |
Prims.Tot | val key:lbytes 32 | [
{
"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
}
] | 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 | val key:lbytes 32
let key:lbytes 32 = | false | null | false | 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": "Spec.Poly1305.Test.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Spec.Poly1305.Test.fst | {
"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"
} | null | val key:lbytes 32 | [] | Spec.Poly1305.Test.key | {
"file_name": "specs/tests/Spec.Poly1305.Test.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 32 | {
"end_col": 11,
"end_line": 38,
"start_col": 21,
"start_line": 30
} |
Prims.Tot | val msg:lbytes 34 | [
{
"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
}
] | 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 | val msg:lbytes 34
let msg:lbytes 34 = | false | null | false | 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": "Spec.Poly1305.Test.fst.checked",
"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"
} | [
"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"
] | [] | 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 *)
(* ********************* *) | false | false | Spec.Poly1305.Test.fst | {
"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"
} | null | val msg:lbytes 34 | [] | Spec.Poly1305.Test.msg | {
"file_name": "specs/tests/Spec.Poly1305.Test.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 34 | {
"end_col": 11,
"end_line": 27,
"start_col": 21,
"start_line": 18
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Vale.Transformers.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.PossiblyMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let equiv_states (s1 s2:va_state) = equiv_states s1 s2 | let equiv_states (s1 s2: va_state) = | false | null | false | equiv_states s1 s2 | {
"checked_file": "Vale.Transformers.Transform.fsti.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Transformers.Common.fsti.checked",
"Vale.Def.PossiblyMonad.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Transformers.Transform.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_state",
"Vale.Transformers.Common.equiv_states",
"Prims.logical"
] | [] | (**
This module exposes user-friendly transformers and lemmas for them.
Each transformation takes 1 or more [va_code] object(s) and
produces a [va_code] object, along with additional data. The lemma
guarantees that the produced [va_code] object is semantically
identical to the (first, if more than one) provided [va_code]
object.
The additional data that is generated is always a [pbool] which is
[ttrue] if the transformation succeeded, and otherwise is a [ffalse
reason]. Under both circumstances, the lemma mentioned above is
held, and in particular, a failed transformation is still safe to
use (since in that case, the code returned is exactly the same as
the first [va_code] object). The additional data is provided only
for debugging, since we expect that after debugging and fixing
things, all transformations will succeed.
*)
module Vale.Transformers.Transform
open Vale.X64.Machine_s
open Vale.Def.PossiblyMonad
open Vale.X64.Decls
open Vale.Transformers.Common | false | true | Vale.Transformers.Transform.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val equiv_states : s1: Vale.X64.Decls.va_state -> s2: Vale.X64.Decls.va_state -> Prims.logical | [] | Vale.Transformers.Transform.equiv_states | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.Transform.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s1: Vale.X64.Decls.va_state -> s2: Vale.X64.Decls.va_state -> Prims.logical | {
"end_col": 61,
"end_line": 29,
"start_col": 43,
"start_line": 29
} |
|
Prims.Tot | val empty_seq_quad32:seq quad32 | [
{
"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
}
] | false | let empty_seq_quad32 : seq quad32 = empty | val empty_seq_quad32:seq quad32
let empty_seq_quad32:seq quad32 = | false | null | false | empty | {
"checked_file": "Vale.AES.GCTR.fsti.checked",
"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"
} | [
"total"
] | [
"FStar.Seq.Base.empty",
"Vale.Def.Types_s.quad32"
] | [] | 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 | false | true | Vale.AES.GCTR.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val empty_seq_quad32:seq quad32 | [] | Vale.AES.GCTR.empty_seq_quad32 | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | FStar.Seq.Base.seq Vale.Def.Types_s.quad32 | {
"end_col": 41,
"end_line": 27,
"start_col": 36,
"start_line": 27
} |
Prims.Tot | val make_gctr_plain_LE (p: seq nat8) : seq nat8 | [
{
"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
}
] | false | let make_gctr_plain_LE (p:seq nat8) : seq nat8 =
if length p < pow2_32 then p else empty | val make_gctr_plain_LE (p: seq nat8) : seq nat8
let make_gctr_plain_LE (p: seq nat8) : seq nat8 = | false | null | false | if length p < pow2_32 then p else empty | {
"checked_file": "Vale.AES.GCTR.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Vale.AES.GCTR.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val make_gctr_plain_LE (p: seq nat8) : seq nat8 | [] | Vale.AES.GCTR.make_gctr_plain_LE | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: FStar.Seq.Base.seq Vale.Def.Types_s.nat8 -> FStar.Seq.Base.seq Vale.Def.Types_s.nat8 | {
"end_col": 41,
"end_line": 17,
"start_col": 2,
"start_line": 17
} |
Prims.Tot | [
{
"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
}
] | false | let gctr_partial = opaque_make gctr_partial_def | let gctr_partial = | false | null | false | opaque_make gctr_partial_def | {
"checked_file": "Vale.AES.GCTR.fsti.checked",
"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"
} | [
"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"
] | [] | 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 ==> | false | true | Vale.AES.GCTR.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Vale.AES.GCTR.gctr_partial | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
_: 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 | {
"end_col": 66,
"end_line": 97,
"start_col": 38,
"start_line": 97
} |
|
FStar.Pervasives.Lemma | [
{
"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
}
] | false | let gctr_partial_reveal = opaque_revealer (`%gctr_partial) gctr_partial gctr_partial_def | let gctr_partial_reveal = | false | null | true | opaque_revealer (`%gctr_partial) gctr_partial gctr_partial_def | {
"checked_file": "Vale.AES.GCTR.fsti.checked",
"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"
} | [
"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"
] | [] | 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))) | false | false | Vale.AES.GCTR.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gctr_partial_reveal : _: Prims.unit
-> FStar.Pervasives.Lemma (ensures Vale.AES.GCTR.gctr_partial == Vale.AES.GCTR.gctr_partial_def) | [] | Vale.AES.GCTR.gctr_partial_reveal | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit
-> FStar.Pervasives.Lemma (ensures Vale.AES.GCTR.gctr_partial == Vale.AES.GCTR.gctr_partial_def) | {
"end_col": 100,
"end_line": 98,
"start_col": 38,
"start_line": 98
} |
|
Prims.Tot | [
{
"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
}
] | false | let gctr_registers = opaque_make gctr_registers_def | let gctr_registers = | false | null | false | opaque_make gctr_registers_def | {
"checked_file": "Vale.AES.GCTR.fsti.checked",
"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"
} | [
"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"
] | [] | 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))) /\ | false | true | Vale.AES.GCTR.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Vale.AES.GCTR.gctr_registers | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
_: 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 | {
"end_col": 70,
"end_line": 89,
"start_col": 40,
"start_line": 89
} |
|
FStar.Pervasives.Lemma | [
{
"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
}
] | false | let gctr_registers_reveal = opaque_revealer (`%gctr_registers) gctr_registers gctr_registers_def | let gctr_registers_reveal = | false | null | true | opaque_revealer (`%gctr_registers) gctr_registers gctr_registers_def | {
"checked_file": "Vale.AES.GCTR.fsti.checked",
"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"
} | [
"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"
] | [] | 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))) | false | false | Vale.AES.GCTR.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gctr_registers_reveal : _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures Vale.AES.GCTR.gctr_registers == Vale.AES.GCTR.gctr_registers_def) | [] | Vale.AES.GCTR.gctr_registers_reveal | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures Vale.AES.GCTR.gctr_registers == Vale.AES.GCTR.gctr_registers_def) | {
"end_col": 108,
"end_line": 90,
"start_col": 40,
"start_line": 90
} |
|
Prims.Pure | val aes_encrypt_BE (alg: algorithm) (key: seq nat32) (p_BE: quad32)
: Pure quad32 (requires is_aes_key_LE alg key) (ensures fun _ -> True) | [
{
"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
}
] | 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 | 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) = | false | null | false | let p_LE = reverse_bytes_quad32 p_BE in
aes_encrypt_LE alg key p_LE | {
"checked_file": "Vale.AES.GCTR.fsti.checked",
"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"
} | [] | [
"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"
] | [] | 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) | false | false | Vale.AES.GCTR.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val aes_encrypt_BE (alg: algorithm) (key: seq nat32) (p_BE: quad32)
: Pure quad32 (requires is_aes_key_LE alg key) (ensures fun _ -> True) | [] | Vale.AES.GCTR.aes_encrypt_BE | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 29,
"end_line": 78,
"start_col": 3,
"start_line": 76
} |
Prims.Tot | val inc32lite (cb: quad32) (i: int) : quad32 | [
{
"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
}
] | 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 | val inc32lite (cb: quad32) (i: int) : quad32
let inc32lite (cb: quad32) (i: int) : quad32 = | false | null | false | 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": "Vale.AES.GCTR.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Vale.AES.GCTR.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val inc32lite (cb: quad32) (i: int) : quad32 | [] | Vale.AES.GCTR.inc32lite | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | cb: Vale.Def.Types_s.quad32 -> i: Prims.int -> Vale.Def.Types_s.quad32 | {
"end_col": 22,
"end_line": 25,
"start_col": 2,
"start_line": 20
} |
Prims.Tot | [
{
"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
}
] | false | 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 partial_seq_agreement (x y: seq quad32) (lo hi: nat) = | false | null | false | 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) | {
"checked_file": "Vale.AES.GCTR.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.AES.GCTR.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Vale.AES.GCTR.partial_seq_agreement | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 97,
"end_line": 36,
"start_col": 2,
"start_line": 35
} |
|
Prims.Tot | val gctr_partial_def
(alg: algorithm)
(bound: nat)
(plain cipher: seq quad32)
(key: seq nat32)
(icb: quad32)
: prop0 | [
{
"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
}
] | 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))) | 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 = | false | null | false | 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": "Vale.AES.GCTR.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Vale.AES.GCTR.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gctr_partial_def
(alg: algorithm)
(bound: nat)
(plain cipher: seq quad32)
(key: seq nat32)
(icb: quad32)
: prop0 | [] | Vale.AES.GCTR.gctr_partial_def | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 90,
"end_line": 96,
"start_col": 2,
"start_line": 93
} |
Prims.Tot | 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 | [
{
"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
}
] | 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))) | 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 = | false | null | false | 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": "Vale.AES.GCTR.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Vale.AES.GCTR.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gctr_registers_def
(r0 r1 r2 r3 r4 r5: quad32)
(s: seq quad32)
(alg: algorithm)
(key: seq nat32)
(ctr_BE: quad32)
(i: int)
: prop0 | [] | Vale.AES.GCTR.gctr_registers_def | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 91,
"end_line": 88,
"start_col": 2,
"start_line": 81
} |
Prims.Tot | val va_wp_Vmr (dst src: va_operand_vec_opr) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_Vmr (dst src: va_operand_vec_opr) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Vmr (dst src: va_operand_vec_opr) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))
) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 -> | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vmr (dst src: va_operand_vec_opr) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vmr | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 99,
"end_line": 47,
"start_col": 2,
"start_line": 45
} |
Prims.Tot | val va_wp_Vslw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vslw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vslw | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 30,
"end_line": 380,
"start_col": 2,
"start_line": 368
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Vale.PPC64LE.InsVector.va_wp_Load128_buffer | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 10,
"end_line": 973,
"start_col": 2,
"start_line": 963
} |
Prims.Tot | val va_wp_Xxmrghd
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Xxmrghd
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Xxmrghd | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 99,
"end_line": 708,
"start_col": 2,
"start_line": 702
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 -> | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Vale.PPC64LE.InsVector.va_wp_Load128_byte16_buffer | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 95,
"end_line": 1344,
"start_col": 2,
"start_line": 1335
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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 (()))) | 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 offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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))))
[@ va_qattr]
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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Vale.PPC64LE.InsVector.va_wp_Load128_byte16_buffer_index | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 52,
"end_line": 1402,
"start_col": 2,
"start_line": 1391
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Mtvsrws
(dst: va_operand_vec_opr)
(src: va_operand_reg_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Mtvsrws | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 80,
"end_line": 212,
"start_col": 2,
"start_line": 205
} |
Prims.Tot | val va_wp_Vncipherlast
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | let va_wp_Vncipherlast (dst: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
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (va_eval_vec_opr va_s0
src1))) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (()))) | val va_wp_Vncipherlast
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Vncipherlast
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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 (Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows
(va_eval_vec_opr va_s0 src1)))
(va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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.AES.AES_common_s.inv_sub_bytes",
"Vale.AES.AES_BE_s.inv_shift_rows",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig))
//--
//-- Vsbox
val va_code_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsbox : 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_Vsbox 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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (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_Vsbox (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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vsbox : 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_Vsbox dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsbox 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_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vsbox dst src)) =
(va_QProc (va_code_Vsbox dst src) ([va_mod_vec_opr dst]) (va_wp_Vsbox dst src) (va_wpProof_Vsbox
dst src))
//--
//-- RotWord
val va_code_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_RotWord : 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_RotWord 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 /\
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8)))
(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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (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_RotWord (dst: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 /\ (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) ==
8 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = 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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))) ==> va_k va_sM (())))
val va_wpProof_RotWord : dst: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_RotWord dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_RotWord 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_RotWord (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_RotWord dst src1 src2)) =
(va_QProc (va_code_RotWord dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_RotWord dst src1 src2)
(va_wpProof_RotWord dst src1 src2))
//--
//-- Vcipher
val va_code_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipher : 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_Vcipher 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 (Vale.AES.AES_BE_s.mix_columns
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (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_Vcipher (dst: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
(Vale.AES.AES_BE_s.mix_columns (Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes
(va_eval_vec_opr va_s0 src1)))) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipher : dst: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_Vcipher dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipher 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_Vcipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vcipher dst src1 src2)) =
(va_QProc (va_code_Vcipher dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipher dst src1 src2)
(va_wpProof_Vcipher dst src1 src2))
//--
//-- Vcipherlast
val va_code_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipherlast : 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_Vcipherlast 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 (Vale.AES.AES_BE_s.shift_rows
(Vale.AES.AES_common_s.sub_bytes (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_Vcipherlast (dst: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
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (va_eval_vec_opr va_s0 src1)))
(va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipherlast : dst: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_Vcipherlast dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipherlast 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_Vcipherlast (dst:va_operand_vec_opr) (src1:va_operand_vec_opr)
(src2:va_operand_vec_opr) : (va_quickCode unit (va_code_Vcipherlast dst src1 src2)) =
(va_QProc (va_code_Vcipherlast dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipherlast dst src1
src2) (va_wpProof_Vcipherlast dst src1 src2))
//--
//-- Vncipher
val va_code_Vncipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vncipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vncipher : 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_Vncipher 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.AES.AES_BE_s.inv_mix_columns (Vale.Def.Types_s.quad32_xor
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (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_Vncipher (dst: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.AES.AES_BE_s.inv_mix_columns (Vale.Def.Types_s.quad32_xor
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (va_eval_vec_opr va_s0
src1))) (va_eval_vec_opr va_s0 src2)) ==> va_k va_sM (())))
val va_wpProof_Vncipher : dst: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_Vncipher dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vncipher 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_Vncipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vncipher dst src1 src2)) =
(va_QProc (va_code_Vncipher dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vncipher dst src1 src2)
(va_wpProof_Vncipher dst src1 src2))
//--
//-- Vncipherlast
val va_code_Vncipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vncipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vncipherlast : 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_Vncipherlast 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 (Vale.AES.AES_common_s.inv_sub_bytes
(Vale.AES.AES_BE_s.inv_shift_rows (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_Vncipherlast (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vncipherlast
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vncipherlast | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 62,
"end_line": 1936,
"start_col": 2,
"start_line": 1932
} |
Prims.Tot | val va_wp_Vcipherlast
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | let va_wp_Vcipherlast (dst: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
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (va_eval_vec_opr va_s0 src1)))
(va_eval_vec_opr va_s0 src2) ==> va_k va_sM (()))) | val va_wp_Vcipherlast
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Vcipherlast
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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 (Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (va_eval_vec_opr
va_s0
src1)))
(va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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.AES.AES_BE_s.shift_rows",
"Vale.AES.AES_common_s.sub_bytes",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig))
//--
//-- Vsbox
val va_code_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsbox : 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_Vsbox 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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (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_Vsbox (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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vsbox : 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_Vsbox dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsbox 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_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vsbox dst src)) =
(va_QProc (va_code_Vsbox dst src) ([va_mod_vec_opr dst]) (va_wp_Vsbox dst src) (va_wpProof_Vsbox
dst src))
//--
//-- RotWord
val va_code_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_RotWord : 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_RotWord 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 /\
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8)))
(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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (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_RotWord (dst: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 /\ (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) ==
8 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = 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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))) ==> va_k va_sM (())))
val va_wpProof_RotWord : dst: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_RotWord dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_RotWord 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_RotWord (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_RotWord dst src1 src2)) =
(va_QProc (va_code_RotWord dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_RotWord dst src1 src2)
(va_wpProof_RotWord dst src1 src2))
//--
//-- Vcipher
val va_code_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipher : 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_Vcipher 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 (Vale.AES.AES_BE_s.mix_columns
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (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_Vcipher (dst: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
(Vale.AES.AES_BE_s.mix_columns (Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes
(va_eval_vec_opr va_s0 src1)))) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipher : dst: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_Vcipher dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipher 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_Vcipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vcipher dst src1 src2)) =
(va_QProc (va_code_Vcipher dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipher dst src1 src2)
(va_wpProof_Vcipher dst src1 src2))
//--
//-- Vcipherlast
val va_code_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipherlast : 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_Vcipherlast 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 (Vale.AES.AES_BE_s.shift_rows
(Vale.AES.AES_common_s.sub_bytes (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_Vcipherlast (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vcipherlast
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vcipherlast | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 54,
"end_line": 1858,
"start_col": 2,
"start_line": 1854
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Mfvsrd
(dst: va_operand_reg_opr)
(src: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Mfvsrd | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 30,
"end_line": 81,
"start_col": 2,
"start_line": 78
} |
Prims.Tot | val va_wp_Vspltw
(dst src: va_operand_vec_opr)
(uim: nat2)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src: va_operand_vec_opr)
(uim: nat2)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vspltw
(dst src: va_operand_vec_opr)
(uim: nat2)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vspltw | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 99,
"end_line": 847,
"start_col": 2,
"start_line": 826
} |
Prims.Tot | val va_wp_Vsrw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vsrw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vsrw | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 30,
"end_line": 433,
"start_col": 2,
"start_line": 421
} |
Prims.Tot | val va_wp_Vsel
(dst src1 src2 sel: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src1 src2 sel: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vsel
(dst src1 src2 sel: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vsel | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 98,
"end_line": 775,
"start_col": 2,
"start_line": 757
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Vale.PPC64LE.InsVector.va_wp_Load128_word4_buffer_index | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 74,
"end_line": 1161,
"start_col": 2,
"start_line": 1145
} |
Prims.Tot | val va_wp_Vsbox (dst src: va_operand_vec_opr) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | let va_wp_Vsbox (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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0 src))) ==> va_k va_sM (()))) | val va_wp_Vsbox (dst src: va_operand_vec_opr) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Vsbox (dst src: va_operand_vec_opr) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0
src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr
va_s0
src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr
va_s0
src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0
src))) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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.AES.AES_common_s.sub_word",
"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.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig))
//--
//-- Vsbox
val va_code_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsbox : 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_Vsbox 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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (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_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (va_s0:va_state) (va_k:(va_state | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vsbox (dst src: va_operand_vec_opr) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vsbox | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 38,
"end_line": 1727,
"start_col": 2,
"start_line": 1719
} |
Prims.Tot | val va_wp_Vncipher
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | let va_wp_Vncipher (dst: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.AES.AES_BE_s.inv_mix_columns (Vale.Def.Types_s.quad32_xor
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (va_eval_vec_opr va_s0
src1))) (va_eval_vec_opr va_s0 src2)) ==> va_k va_sM (()))) | val va_wp_Vncipher
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Vncipher
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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.AES.AES_BE_s.inv_mix_columns (Vale.Def.Types_s.quad32_xor (Vale.AES.AES_common_s.inv_sub_bytes
(Vale.AES.AES_BE_s.inv_shift_rows (va_eval_vec_opr va_s0 src1)))
(va_eval_vec_opr va_s0 src2)) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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.AES.AES_BE_s.inv_mix_columns",
"Vale.Def.Types_s.quad32_xor",
"Vale.AES.AES_common_s.inv_sub_bytes",
"Vale.AES.AES_BE_s.inv_shift_rows",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig))
//--
//-- Vsbox
val va_code_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsbox : 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_Vsbox 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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (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_Vsbox (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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vsbox : 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_Vsbox dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsbox 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_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vsbox dst src)) =
(va_QProc (va_code_Vsbox dst src) ([va_mod_vec_opr dst]) (va_wp_Vsbox dst src) (va_wpProof_Vsbox
dst src))
//--
//-- RotWord
val va_code_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_RotWord : 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_RotWord 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 /\
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8)))
(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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (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_RotWord (dst: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 /\ (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) ==
8 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = 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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))) ==> va_k va_sM (())))
val va_wpProof_RotWord : dst: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_RotWord dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_RotWord 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_RotWord (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_RotWord dst src1 src2)) =
(va_QProc (va_code_RotWord dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_RotWord dst src1 src2)
(va_wpProof_RotWord dst src1 src2))
//--
//-- Vcipher
val va_code_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipher : 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_Vcipher 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 (Vale.AES.AES_BE_s.mix_columns
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (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_Vcipher (dst: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
(Vale.AES.AES_BE_s.mix_columns (Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes
(va_eval_vec_opr va_s0 src1)))) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipher : dst: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_Vcipher dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipher 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_Vcipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vcipher dst src1 src2)) =
(va_QProc (va_code_Vcipher dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipher dst src1 src2)
(va_wpProof_Vcipher dst src1 src2))
//--
//-- Vcipherlast
val va_code_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipherlast : 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_Vcipherlast 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 (Vale.AES.AES_BE_s.shift_rows
(Vale.AES.AES_common_s.sub_bytes (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_Vcipherlast (dst: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
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (va_eval_vec_opr va_s0 src1)))
(va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipherlast : dst: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_Vcipherlast dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipherlast 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_Vcipherlast (dst:va_operand_vec_opr) (src1:va_operand_vec_opr)
(src2:va_operand_vec_opr) : (va_quickCode unit (va_code_Vcipherlast dst src1 src2)) =
(va_QProc (va_code_Vcipherlast dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipherlast dst src1
src2) (va_wpProof_Vcipherlast dst src1 src2))
//--
//-- Vncipher
val va_code_Vncipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vncipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vncipher : 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_Vncipher 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.AES.AES_BE_s.inv_mix_columns (Vale.Def.Types_s.quad32_xor
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (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_Vncipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vncipher
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vncipher | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 63,
"end_line": 1898,
"start_col": 2,
"start_line": 1893
} |
Prims.Tot | val va_wp_Vadduwm
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vadduwm
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vadduwm | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 21,
"end_line": 250,
"start_col": 2,
"start_line": 246
} |
Prims.Tot | val va_quick_Mfvsrd (dst: va_operand_reg_opr) (src: va_operand_vec_opr)
: (va_quickCode unit (va_code_Mfvsrd dst src)) | [
{
"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
}
] | 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)) | 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)) = | false | null | false | (va_QProc (va_code_Mfvsrd dst src)
([va_mod_reg_opr dst])
(va_wp_Mfvsrd dst src)
(va_wpProof_Mfvsrd dst src)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Mfvsrd (dst: va_operand_reg_opr) (src: va_operand_vec_opr)
: (va_quickCode unit (va_code_Mfvsrd dst src)) | [] | Vale.PPC64LE.InsVector.va_quick_Mfvsrd | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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) | {
"end_col": 32,
"end_line": 93,
"start_col": 2,
"start_line": 92
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Mfvsrld
(dst: va_operand_reg_opr)
(src: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Mfvsrld | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 30,
"end_line": 115,
"start_col": 2,
"start_line": 112
} |
Prims.Tot | val 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)) | [
{
"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
}
] | false | 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)) | val 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))
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)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_byte16_buffer",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Load128_byte16_buffer",
"Vale.PPC64LE.InsVector.va_wpProof_Load128_byte16_buffer",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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 | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)) | [] | Vale.PPC64LE.InsVector.va_quick_Load128_byte16_buffer | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Load128_byte16_buffer h dst base t) | {
"end_col": 15,
"end_line": 1359,
"start_col": 2,
"start_line": 1357
} |
Prims.Tot | val va_wp_Store128_byte16_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 | [
{
"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
}
] | false | let va_wp_Store128_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (()))) | val va_wp_Store128_byte16_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
let va_wp_Store128_byte16_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 = | false | null | false | (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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_dst_heaplet",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_reg_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Vale.PPC64LE.Decls.valid_dst_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_heaplet",
"Vale.PPC64LE.Memory.vale_heap",
"Prims.l_imp",
"Vale.PPC64LE.InsVector.buffer128_write",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_mem",
"Vale.PPC64LE.Decls.va_upd_operand_heaplet"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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 -> | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Store128_byte16_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 | [] | Vale.PPC64LE.InsVector.va_wp_Store128_byte16_buffer | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
src: 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 | {
"end_col": 51,
"end_line": 1457,
"start_col": 2,
"start_line": 1447
} |
Prims.Tot | val va_wp_Vxor
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vxor
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vxor | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 83,
"end_line": 287,
"start_col": 2,
"start_line": 284
} |
Prims.Tot | val va_quick_Vspltw (dst src: va_operand_vec_opr) (uim: nat2)
: (va_quickCode unit (va_code_Vspltw dst src uim)) | [
{
"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
}
] | false | 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)) | 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 src: va_operand_vec_opr) (uim: nat2)
: (va_quickCode unit (va_code_Vspltw dst src uim)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vspltw (dst src: va_operand_vec_opr) (uim: nat2)
: (va_quickCode unit (va_code_Vspltw dst src uim)) | [] | Vale.PPC64LE.InsVector.va_quick_Vspltw | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 36,
"end_line": 859,
"start_col": 2,
"start_line": 858
} |
Prims.Tot | val va_wp_Store128_buffer
(h: va_operand_heaplet)
(src: 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 | [
{
"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
}
] | false | 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_wp_Store128_buffer
(h: va_operand_heaplet)
(src: 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_Store128_buffer
(h: va_operand_heaplet)
(src: 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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_dst_heaplet",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_reg_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Vale.PPC64LE.Decls.valid_dst_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_heaplet",
"Vale.PPC64LE.Memory.vale_heap",
"Prims.l_imp",
"Vale.PPC64LE.InsVector.buffer128_write",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_mem",
"Vale.PPC64LE.Decls.va_upd_operand_heaplet"
] | [] | 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 | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Store128_buffer
(h: va_operand_heaplet)
(src: 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 | [] | Vale.PPC64LE.InsVector.va_wp_Store128_buffer | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
src: 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 | {
"end_col": 56,
"end_line": 1029,
"start_col": 2,
"start_line": 1019
} |
Prims.Tot | val 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 | [
{
"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
}
] | false | 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_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
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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_dst_heaplet",
"Vale.PPC64LE.Decls.va_is_src_vec_opr",
"Vale.PPC64LE.Decls.va_is_src_reg_opr",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Vale.PPC64LE.Decls.valid_dst_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_heaplet",
"Vale.PPC64LE.Memory.vale_heap",
"Prims.l_imp",
"Vale.PPC64LE.InsVector.buffer128_write",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"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_mem",
"Vale.PPC64LE.Decls.va_upd_operand_heaplet"
] | [] | 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 -> | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Vale.PPC64LE.InsVector.va_wp_Store128_word4_buffer | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
src: 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 | {
"end_col": 34,
"end_line": 1224,
"start_col": 2,
"start_line": 1210
} |
Prims.Tot | val va_wp_Vmrghw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vmrghw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vmrghw | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 99,
"end_line": 665,
"start_col": 2,
"start_line": 659
} |
Prims.Ghost | 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) | [
{
"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
}
] | 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 | 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) = | false | null | false | buffer_write b i v h | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [] | [
"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"
] | [] | 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) | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Vale.PPC64LE.InsVector.buffer128_write | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 22,
"end_line": 27,
"start_col": 2,
"start_line": 27
} |
Prims.Tot | val va_wp_SHA256_Sigma1
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (()))) | val va_wp_SHA256_Sigma1
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_SHA256_Sigma1
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index #Vale.SHA.PPC64LE.SHA_helpers.word
(Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block hash_orig)
4) /\
(forall (va_x_dst: 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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig ==>
va_k va_sM (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.SHA.PPC64LE.SHA_helpers.hash256",
"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.op_LessThan",
"Vale.SHA.PPC64LE.SHA_helpers.size_k_w_256",
"Prims.eq2",
"Vale.Def.Words_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32",
"FStar.Seq.Base.index",
"Vale.SHA.PPC64LE.SHA_helpers.word",
"Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_SHA256_Sigma1
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_SHA256_Sigma1 | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src: Vale.PPC64LE.Decls.va_operand_vec_opr ->
t: Vale.SHA.PPC64LE.SHA_helpers.counter ->
block: Vale.SHA.PPC64LE.SHA_helpers.block_w ->
hash_orig: Vale.SHA.PPC64LE.SHA_helpers.hash256 ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 25,
"end_line": 1682,
"start_col": 2,
"start_line": 1675
} |
Prims.Tot | val 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)) | [
{
"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
}
] | false | 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)) | val 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))
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)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_Store128_word4_buffer",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_Mod_mem",
"Vale.PPC64LE.QuickCode.va_mod_heaplet",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Store128_word4_buffer",
"Vale.PPC64LE.InsVector.va_wpProof_Store128_word4_buffer",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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 | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)) | [] | Vale.PPC64LE.InsVector.va_quick_Store128_word4_buffer | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
src: 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
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Store128_word4_buffer h src base t) | {
"end_col": 15,
"end_line": 1239,
"start_col": 2,
"start_line": 1237
} |
Prims.Tot | val va_quick_Vxor (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vxor dst src1 src2)) | [
{
"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
}
] | false | 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)) | 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 src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vxor dst src1 src2)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vxor (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vxor dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Vxor | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 36,
"end_line": 299,
"start_col": 2,
"start_line": 298
} |
Prims.Tot | val va_quick_SHA256_sigma0 (dst src: va_operand_vec_opr) (t: counter) (block: block_w)
: (va_quickCode unit (va_code_SHA256_sigma0 dst src)) | [
{
"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
}
] | false | let va_quick_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block)) | val va_quick_SHA256_sigma0 (dst src: va_operand_vec_opr) (t: counter) (block: block_w)
: (va_quickCode unit (va_code_SHA256_sigma0 dst src))
let va_quick_SHA256_sigma0 (dst src: va_operand_vec_opr) (t: counter) (block: block_w)
: (va_quickCode unit (va_code_SHA256_sigma0 dst src)) = | false | null | false | (va_QProc (va_code_SHA256_sigma0 dst src)
([va_mod_vec_opr dst])
(va_wp_SHA256_sigma0 dst src t block)
(va_wpProof_SHA256_sigma0 dst src t block)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_SHA256_sigma0",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_SHA256_sigma0",
"Vale.PPC64LE.InsVector.va_wpProof_SHA256_sigma0",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter) | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_SHA256_sigma0 (dst src: va_operand_vec_opr) (t: counter) (block: block_w)
: (va_quickCode unit (va_code_SHA256_sigma0 dst src)) | [] | Vale.PPC64LE.InsVector.va_quick_SHA256_sigma0 | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src: Vale.PPC64LE.Decls.va_operand_vec_opr ->
t: Vale.SHA.PPC64LE.SHA_helpers.counter ->
block: Vale.SHA.PPC64LE.SHA_helpers.block_w
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_SHA256_sigma0 dst src) | {
"end_col": 54,
"end_line": 1569,
"start_col": 2,
"start_line": 1568
} |
Prims.Tot | val va_wp_Store128_byte16_buffer_index
(h: va_operand_heaplet)
(src: 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 | [
{
"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
}
] | false | let va_wp_Store128_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (()))) | val va_wp_Store128_byte16_buffer_index
(h: va_operand_heaplet)
(src: 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_Store128_byte16_buffer_index
(h: va_operand_heaplet)
(src: 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 = | false | null | false | (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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_dst_heaplet",
"Vale.PPC64LE.Decls.va_is_src_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_dst_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_heaplet",
"Vale.PPC64LE.Memory.vale_heap",
"Prims.l_imp",
"Vale.PPC64LE.InsVector.buffer128_write",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_mem",
"Vale.PPC64LE.Decls.va_upd_operand_heaplet"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Store128_byte16_buffer_index
(h: va_operand_heaplet)
(src: 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 | [] | Vale.PPC64LE.InsVector.va_wp_Store128_byte16_buffer_index | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
src: 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 | {
"end_col": 80,
"end_line": 1516,
"start_col": 2,
"start_line": 1505
} |
Prims.Tot | val va_quick_Mtvsrdd (dst: va_operand_vec_opr) (src1 src2: va_operand_reg_opr)
: (va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) | [
{
"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
}
] | false | 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)) | 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 src2: va_operand_reg_opr)
: (va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Mtvsrdd (dst: va_operand_vec_opr) (src1 src2: va_operand_reg_opr)
: (va_quickCode unit (va_code_Mtvsrdd dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Mtvsrdd | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 39,
"end_line": 181,
"start_col": 2,
"start_line": 180
} |
Prims.Tot | val va_wp_SHA256_Sigma0
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (()))) | val va_wp_SHA256_Sigma0
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_SHA256_Sigma0
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index #Vale.SHA.PPC64LE.SHA_helpers.word
(Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block hash_orig)
0) /\
(forall (va_x_dst: 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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig ==>
va_k va_sM (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.SHA.PPC64LE.SHA_helpers.hash256",
"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.op_LessThan",
"Vale.SHA.PPC64LE.SHA_helpers.size_k_w_256",
"Prims.eq2",
"Vale.Def.Words_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32",
"FStar.Seq.Base.index",
"Vale.SHA.PPC64LE.SHA_helpers.word",
"Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_SHA256_Sigma0
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_SHA256_Sigma0 | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src: Vale.PPC64LE.Decls.va_operand_vec_opr ->
t: Vale.SHA.PPC64LE.SHA_helpers.counter ->
block: Vale.SHA.PPC64LE.SHA_helpers.block_w ->
hash_orig: Vale.SHA.PPC64LE.SHA_helpers.hash256 ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 25,
"end_line": 1638,
"start_col": 2,
"start_line": 1631
} |
Prims.Tot | val va_quick_Mfvsrld (dst: va_operand_reg_opr) (src: va_operand_vec_opr)
: (va_quickCode unit (va_code_Mfvsrld dst src)) | [
{
"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
}
] | 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)) | 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)) = | false | null | false | (va_QProc (va_code_Mfvsrld dst src)
([va_mod_reg_opr dst])
(va_wp_Mfvsrld dst src)
(va_wpProof_Mfvsrld dst src)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Mfvsrld (dst: va_operand_reg_opr) (src: va_operand_vec_opr)
: (va_quickCode unit (va_code_Mfvsrld dst src)) | [] | Vale.PPC64LE.InsVector.va_quick_Mfvsrld | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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) | {
"end_col": 33,
"end_line": 127,
"start_col": 2,
"start_line": 126
} |
Prims.Tot | val va_wp_Vand
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vand
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vand | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 21,
"end_line": 327,
"start_col": 2,
"start_line": 322
} |
Prims.Tot | val va_quick_Vadduwm (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vadduwm dst src1 src2)) | [
{
"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
}
] | false | 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)) | 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 src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vadduwm dst src1 src2)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vadduwm (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vadduwm dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Vadduwm | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 39,
"end_line": 262,
"start_col": 2,
"start_line": 261
} |
Prims.Tot | val va_quick_Vslw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vslw dst src1 src2)) | [
{
"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
}
] | false | 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)) | 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 src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vslw dst src1 src2)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vslw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vslw dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Vslw | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 36,
"end_line": 392,
"start_col": 2,
"start_line": 391
} |
Prims.Tot | val va_quick_Vmrghw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vmrghw dst src1 src2)) | [
{
"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
}
] | false | 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)) | 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 src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vmrghw dst src1 src2)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vmrghw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vmrghw dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Vmrghw | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 38,
"end_line": 677,
"start_col": 2,
"start_line": 676
} |
Prims.Tot | val va_wp_Vspltisw
(dst: va_operand_vec_opr)
(src: sim)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 -> | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vspltisw
(dst: va_operand_vec_opr)
(src: sim)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vspltisw | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 90,
"end_line": 881,
"start_col": 2,
"start_line": 878
} |
Prims.Tot | val va_quick_RotWord (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_RotWord dst src1 src2)) | [
{
"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
}
] | false | let va_quick_RotWord (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_RotWord dst src1 src2)) =
(va_QProc (va_code_RotWord dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_RotWord dst src1 src2)
(va_wpProof_RotWord dst src1 src2)) | val va_quick_RotWord (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_RotWord dst src1 src2))
let va_quick_RotWord (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_RotWord dst src1 src2)) = | false | null | false | (va_QProc (va_code_RotWord dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_RotWord dst src1 src2)
(va_wpProof_RotWord dst src1 src2)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_RotWord",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_RotWord",
"Vale.PPC64LE.InsVector.va_wpProof_RotWord",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig))
//--
//-- Vsbox
val va_code_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsbox : 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_Vsbox 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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (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_Vsbox (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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vsbox : 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_Vsbox dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsbox 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_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vsbox dst src)) =
(va_QProc (va_code_Vsbox dst src) ([va_mod_vec_opr dst]) (va_wp_Vsbox dst src) (va_wpProof_Vsbox
dst src))
//--
//-- RotWord
val va_code_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_RotWord : 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_RotWord 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 /\
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8)))
(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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (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_RotWord (dst: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 /\ (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) ==
8 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = 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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))) ==> va_k va_sM (())))
val va_wpProof_RotWord : dst: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_RotWord dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_RotWord 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_RotWord (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_RotWord (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_RotWord dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_RotWord | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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_RotWord dst src1 src2) | {
"end_col": 39,
"end_line": 1793,
"start_col": 2,
"start_line": 1792
} |
Prims.Tot | val va_wp_Vsldoi
(dst src1 src2: va_operand_vec_opr)
(count: quad32bytes)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src1 src2: va_operand_vec_opr)
(count: quad32bytes)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vsldoi
(dst src1 src2: va_operand_vec_opr)
(count: quad32bytes)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vsldoi | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 100,
"end_line": 622,
"start_col": 2,
"start_line": 605
} |
Prims.Tot | val va_quick_SHA256_sigma1 (dst src: va_operand_vec_opr) (t: counter) (block: block_w)
: (va_quickCode unit (va_code_SHA256_sigma1 dst src)) | [
{
"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
}
] | false | let va_quick_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block)) | val va_quick_SHA256_sigma1 (dst src: va_operand_vec_opr) (t: counter) (block: block_w)
: (va_quickCode unit (va_code_SHA256_sigma1 dst src))
let va_quick_SHA256_sigma1 (dst src: va_operand_vec_opr) (t: counter) (block: block_w)
: (va_quickCode unit (va_code_SHA256_sigma1 dst src)) = | false | null | false | (va_QProc (va_code_SHA256_sigma1 dst src)
([va_mod_vec_opr dst])
(va_wp_SHA256_sigma1 dst src t block)
(va_wpProof_SHA256_sigma1 dst src t block)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_SHA256_sigma1",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_SHA256_sigma1",
"Vale.PPC64LE.InsVector.va_wpProof_SHA256_sigma1",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter) | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_SHA256_sigma1 (dst src: va_operand_vec_opr) (t: counter) (block: block_w)
: (va_quickCode unit (va_code_SHA256_sigma1 dst src)) | [] | Vale.PPC64LE.InsVector.va_quick_SHA256_sigma1 | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src: Vale.PPC64LE.Decls.va_operand_vec_opr ->
t: Vale.SHA.PPC64LE.SHA_helpers.counter ->
block: Vale.SHA.PPC64LE.SHA_helpers.block_w
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_SHA256_sigma1 dst src) | {
"end_col": 54,
"end_line": 1606,
"start_col": 2,
"start_line": 1605
} |
Prims.Tot | val va_quick_Vsrw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsrw dst src1 src2)) | [
{
"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
}
] | false | 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)) | 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 src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsrw dst src1 src2)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vsrw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsrw dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Vsrw | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 36,
"end_line": 445,
"start_col": 2,
"start_line": 444
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 src2: va_operand_reg_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Vale.PPC64LE.InsVector.va_wp_Mtvsrdd | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 100,
"end_line": 169,
"start_col": 2,
"start_line": 157
} |
Prims.Tot | val va_quick_Vsl (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsl dst src1 src2)) | [
{
"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
}
] | false | 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)) | 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 src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsl dst src1 src2)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vsl (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsl dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Vsl | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 35,
"end_line": 516,
"start_col": 2,
"start_line": 515
} |
Prims.Tot | val va_quick_Vcmpequw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) | [
{
"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
}
] | false | 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)) | 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 src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vcmpequw (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcmpequw dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Vcmpequw | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 40,
"end_line": 569,
"start_col": 2,
"start_line": 568
} |
Prims.Tot | val va_wp_Vcmpequw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vcmpequw
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vcmpequw | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 39,
"end_line": 557,
"start_col": 2,
"start_line": 545
} |
Prims.Tot | val va_quick_Store128_byte16_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_byte16_buffer h src base t)) | [
{
"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
}
] | false | let va_quick_Store128_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index)) | val va_quick_Store128_byte16_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_byte16_buffer h src base t))
let va_quick_Store128_byte16_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_byte16_buffer h src base t)) = | false | null | false | (va_QProc (va_code_Store128_byte16_buffer h src base t)
([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index)
(va_wpProof_Store128_byte16_buffer h src base t b index)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_Store128_byte16_buffer",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_Mod_mem",
"Vale.PPC64LE.QuickCode.va_mod_heaplet",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Store128_byte16_buffer",
"Vale.PPC64LE.InsVector.va_wpProof_Store128_byte16_buffer",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_buffer (h:va_operand_heaplet) (src:va_operand_vec_opr)
(base:va_operand_reg_opr) (t:taint) (b:buffer128) (index:int) : (va_quickCode unit | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Store128_byte16_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_byte16_buffer h src base t)) | [] | Vale.PPC64LE.InsVector.va_quick_Store128_byte16_buffer | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
src: 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
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Store128_byte16_buffer h src base t) | {
"end_col": 20,
"end_line": 1472,
"start_col": 2,
"start_line": 1470
} |
Prims.Tot | val va_quick_Vcipher (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcipher dst src1 src2)) | [
{
"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
}
] | false | let va_quick_Vcipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vcipher dst src1 src2)) =
(va_QProc (va_code_Vcipher dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipher dst src1 src2)
(va_wpProof_Vcipher dst src1 src2)) | val va_quick_Vcipher (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcipher dst src1 src2))
let va_quick_Vcipher (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcipher dst src1 src2)) = | false | null | false | (va_QProc (va_code_Vcipher dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Vcipher dst src1 src2)
(va_wpProof_Vcipher dst src1 src2)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vcipher",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vcipher",
"Vale.PPC64LE.InsVector.va_wpProof_Vcipher",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig))
//--
//-- Vsbox
val va_code_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsbox : 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_Vsbox 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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (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_Vsbox (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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vsbox : 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_Vsbox dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsbox 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_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vsbox dst src)) =
(va_QProc (va_code_Vsbox dst src) ([va_mod_vec_opr dst]) (va_wp_Vsbox dst src) (va_wpProof_Vsbox
dst src))
//--
//-- RotWord
val va_code_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_RotWord : 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_RotWord 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 /\
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8)))
(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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (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_RotWord (dst: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 /\ (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) ==
8 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = 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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))) ==> va_k va_sM (())))
val va_wpProof_RotWord : dst: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_RotWord dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_RotWord 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_RotWord (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_RotWord dst src1 src2)) =
(va_QProc (va_code_RotWord dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_RotWord dst src1 src2)
(va_wpProof_RotWord dst src1 src2))
//--
//-- Vcipher
val va_code_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipher : 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_Vcipher 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 (Vale.AES.AES_BE_s.mix_columns
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (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_Vcipher (dst: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
(Vale.AES.AES_BE_s.mix_columns (Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes
(va_eval_vec_opr va_s0 src1)))) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipher : dst: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_Vcipher dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipher 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_Vcipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vcipher (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcipher dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Vcipher | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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_Vcipher dst src1 src2) | {
"end_col": 39,
"end_line": 1832,
"start_col": 2,
"start_line": 1831
} |
Prims.Tot | val va_quick_Vcipherlast (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcipherlast dst src1 src2)) | [
{
"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
}
] | false | let va_quick_Vcipherlast (dst:va_operand_vec_opr) (src1:va_operand_vec_opr)
(src2:va_operand_vec_opr) : (va_quickCode unit (va_code_Vcipherlast dst src1 src2)) =
(va_QProc (va_code_Vcipherlast dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipherlast dst src1
src2) (va_wpProof_Vcipherlast dst src1 src2)) | val va_quick_Vcipherlast (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcipherlast dst src1 src2))
let va_quick_Vcipherlast (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcipherlast dst src1 src2)) = | false | null | false | (va_QProc (va_code_Vcipherlast dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Vcipherlast dst src1 src2)
(va_wpProof_Vcipherlast dst src1 src2)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vcipherlast",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vcipherlast",
"Vale.PPC64LE.InsVector.va_wpProof_Vcipherlast",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig))
//--
//-- Vsbox
val va_code_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsbox : 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_Vsbox 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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (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_Vsbox (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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vsbox : 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_Vsbox dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsbox 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_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vsbox dst src)) =
(va_QProc (va_code_Vsbox dst src) ([va_mod_vec_opr dst]) (va_wp_Vsbox dst src) (va_wpProof_Vsbox
dst src))
//--
//-- RotWord
val va_code_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_RotWord : 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_RotWord 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 /\
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8)))
(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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (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_RotWord (dst: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 /\ (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) ==
8 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = 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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))) ==> va_k va_sM (())))
val va_wpProof_RotWord : dst: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_RotWord dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_RotWord 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_RotWord (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_RotWord dst src1 src2)) =
(va_QProc (va_code_RotWord dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_RotWord dst src1 src2)
(va_wpProof_RotWord dst src1 src2))
//--
//-- Vcipher
val va_code_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipher : 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_Vcipher 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 (Vale.AES.AES_BE_s.mix_columns
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (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_Vcipher (dst: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
(Vale.AES.AES_BE_s.mix_columns (Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes
(va_eval_vec_opr va_s0 src1)))) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipher : dst: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_Vcipher dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipher 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_Vcipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vcipher dst src1 src2)) =
(va_QProc (va_code_Vcipher dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipher dst src1 src2)
(va_wpProof_Vcipher dst src1 src2))
//--
//-- Vcipherlast
val va_code_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipherlast : 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_Vcipherlast 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 (Vale.AES.AES_BE_s.shift_rows
(Vale.AES.AES_common_s.sub_bytes (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_Vcipherlast (dst: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
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (va_eval_vec_opr va_s0 src1)))
(va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipherlast : dst: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_Vcipherlast dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipherlast 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_Vcipherlast (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vcipherlast (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vcipherlast dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Vcipherlast | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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_Vcipherlast dst src1 src2) | {
"end_col": 49,
"end_line": 1870,
"start_col": 2,
"start_line": 1869
} |
Prims.Tot | val va_quick_Vand (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vand dst src1 src2)) | [
{
"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
}
] | false | 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)) | 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 src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vand dst src1 src2)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vand (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vand dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Vand | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 36,
"end_line": 339,
"start_col": 2,
"start_line": 338
} |
Prims.Tot | val va_wp_SHA256_sigma0
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(()))) | val va_wp_SHA256_sigma0
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_SHA256_sigma0
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\
((16 <= t && t < size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==>
va_k va_sM (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"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.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Vale.SHA.PPC64LE.SHA_helpers.size_k_w_256",
"Prims.eq2",
"Vale.Def.Words_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.SHA.PPC64LE.SHA_helpers.ws_opaque",
"Prims.op_Subtraction",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_0_0_partial",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_SHA256_sigma0
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_SHA256_sigma0 | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src: Vale.PPC64LE.Decls.va_operand_vec_opr ->
t: Vale.SHA.PPC64LE.SHA_helpers.counter ->
block: Vale.SHA.PPC64LE.SHA_helpers.block_w ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 10,
"end_line": 1557,
"start_col": 2,
"start_line": 1553
} |
Prims.Tot | val 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)) | [
{
"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
}
] | false | 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)) | val 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))
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)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_word4_buffer",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Load128_word4_buffer",
"Vale.PPC64LE.InsVector.va_wpProof_Load128_word4_buffer",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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 | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)) | [] | Vale.PPC64LE.InsVector.va_quick_Load128_word4_buffer | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_Load128_word4_buffer h dst base t) | {
"end_col": 13,
"end_line": 1108,
"start_col": 2,
"start_line": 1106
} |
Prims.Tot | val va_quick_Mtvsrws (dst: va_operand_vec_opr) (src: va_operand_reg_opr)
: (va_quickCode unit (va_code_Mtvsrws dst src)) | [
{
"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
}
] | 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)) | 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)) = | false | null | false | (va_QProc (va_code_Mtvsrws dst src)
([va_mod_vec_opr dst])
(va_wp_Mtvsrws dst src)
(va_wpProof_Mtvsrws dst src)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Mtvsrws (dst: va_operand_vec_opr) (src: va_operand_reg_opr)
: (va_quickCode unit (va_code_Mtvsrws dst src)) | [] | Vale.PPC64LE.InsVector.va_quick_Mtvsrws | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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) | {
"end_col": 33,
"end_line": 224,
"start_col": 2,
"start_line": 223
} |
Prims.Tot | val va_quick_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) | [
{
"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
}
] | false | let va_quick_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index)) | val va_quick_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t))
let va_quick_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) = | false | null | false | (va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t)
([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_byte16_buffer_index",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Load128_byte16_buffer_index",
"Vale.PPC64LE.InsVector.va_wpProof_Load128_byte16_buffer_index",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) | [] | Vale.PPC64LE.InsVector.va_quick_Load128_byte16_buffer_index | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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_byte16_buffer_index h dst base offset t) | {
"end_col": 73,
"end_line": 1418,
"start_col": 2,
"start_line": 1416
} |
Prims.Tot | val va_wp_Vspltisb
(dst: va_operand_vec_opr)
(src: sim)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 -> | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vspltisb
(dst: va_operand_vec_opr)
(src: sim)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vspltisb | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 21,
"end_line": 921,
"start_col": 2,
"start_line": 915
} |
Prims.Tot | val va_quick_Store128_buffer
(h: va_operand_heaplet)
(src: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Store128_buffer h src base offset t)) | [
{
"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
}
] | false | 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)) | val va_quick_Store128_buffer
(h: va_operand_heaplet)
(src: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Store128_buffer h src base offset t))
let va_quick_Store128_buffer
(h: va_operand_heaplet)
(src: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Store128_buffer h src base offset t)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_Store128_buffer",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_Mod_mem",
"Vale.PPC64LE.QuickCode.va_mod_heaplet",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Store128_buffer",
"Vale.PPC64LE.InsVector.va_wpProof_Store128_buffer",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Store128_buffer
(h: va_operand_heaplet)
(src: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Store128_buffer h src base offset t)) | [] | Vale.PPC64LE.InsVector.va_quick_Store128_buffer | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
src: 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_Store128_buffer h src base offset t) | {
"end_col": 22,
"end_line": 1044,
"start_col": 2,
"start_line": 1042
} |
Prims.Tot | val va_quick_Vncipher (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vncipher dst src1 src2)) | [
{
"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
}
] | false | let va_quick_Vncipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vncipher dst src1 src2)) =
(va_QProc (va_code_Vncipher dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vncipher dst src1 src2)
(va_wpProof_Vncipher dst src1 src2)) | val va_quick_Vncipher (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vncipher dst src1 src2))
let va_quick_Vncipher (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vncipher dst src1 src2)) = | false | null | false | (va_QProc (va_code_Vncipher dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Vncipher dst src1 src2)
(va_wpProof_Vncipher dst src1 src2)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vncipher",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vncipher",
"Vale.PPC64LE.InsVector.va_wpProof_Vncipher",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig))
//--
//-- Vsbox
val va_code_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsbox : 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_Vsbox 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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (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_Vsbox (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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vsbox : 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_Vsbox dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsbox 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_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vsbox dst src)) =
(va_QProc (va_code_Vsbox dst src) ([va_mod_vec_opr dst]) (va_wp_Vsbox dst src) (va_wpProof_Vsbox
dst src))
//--
//-- RotWord
val va_code_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_RotWord : 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_RotWord 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 /\
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8)))
(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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (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_RotWord (dst: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 /\ (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) ==
8 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = 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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))) ==> va_k va_sM (())))
val va_wpProof_RotWord : dst: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_RotWord dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_RotWord 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_RotWord (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_RotWord dst src1 src2)) =
(va_QProc (va_code_RotWord dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_RotWord dst src1 src2)
(va_wpProof_RotWord dst src1 src2))
//--
//-- Vcipher
val va_code_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipher : 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_Vcipher 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 (Vale.AES.AES_BE_s.mix_columns
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (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_Vcipher (dst: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
(Vale.AES.AES_BE_s.mix_columns (Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes
(va_eval_vec_opr va_s0 src1)))) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipher : dst: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_Vcipher dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipher 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_Vcipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vcipher dst src1 src2)) =
(va_QProc (va_code_Vcipher dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipher dst src1 src2)
(va_wpProof_Vcipher dst src1 src2))
//--
//-- Vcipherlast
val va_code_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipherlast : 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_Vcipherlast 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 (Vale.AES.AES_BE_s.shift_rows
(Vale.AES.AES_common_s.sub_bytes (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_Vcipherlast (dst: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
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (va_eval_vec_opr va_s0 src1)))
(va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipherlast : dst: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_Vcipherlast dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipherlast 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_Vcipherlast (dst:va_operand_vec_opr) (src1:va_operand_vec_opr)
(src2:va_operand_vec_opr) : (va_quickCode unit (va_code_Vcipherlast dst src1 src2)) =
(va_QProc (va_code_Vcipherlast dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipherlast dst src1
src2) (va_wpProof_Vcipherlast dst src1 src2))
//--
//-- Vncipher
val va_code_Vncipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vncipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vncipher : 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_Vncipher 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.AES.AES_BE_s.inv_mix_columns (Vale.Def.Types_s.quad32_xor
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (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_Vncipher (dst: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.AES.AES_BE_s.inv_mix_columns (Vale.Def.Types_s.quad32_xor
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (va_eval_vec_opr va_s0
src1))) (va_eval_vec_opr va_s0 src2)) ==> va_k va_sM (())))
val va_wpProof_Vncipher : dst: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_Vncipher dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vncipher 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_Vncipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vncipher (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vncipher dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Vncipher | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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_Vncipher dst src1 src2) | {
"end_col": 40,
"end_line": 1910,
"start_col": 2,
"start_line": 1909
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 -> | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Vale.PPC64LE.InsVector.va_wp_Load128_word4_buffer | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 74,
"end_line": 1093,
"start_col": 2,
"start_line": 1078
} |
Prims.Tot | val va_wp_RotWord
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | let va_wp_RotWord (dst: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 /\ (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) ==
8 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = 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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))) ==> va_k va_sM (()))) | val va_wp_RotWord
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_RotWord
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
va_get_ok va_s0 /\
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8) /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = 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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0
src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0
src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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.eq2",
"Prims.int",
"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",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.Mkfour",
"Vale.AES.AES_BE_s.rot_word",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig))
//--
//-- Vsbox
val va_code_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsbox : 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_Vsbox 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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (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_Vsbox (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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vsbox : 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_Vsbox dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsbox 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_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vsbox dst src)) =
(va_QProc (va_code_Vsbox dst src) ([va_mod_vec_opr dst]) (va_wp_Vsbox dst src) (va_wpProof_Vsbox
dst src))
//--
//-- RotWord
val va_code_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_RotWord : 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_RotWord 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 /\
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8)))
(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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (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_RotWord (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_RotWord
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_RotWord | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 33,
"end_line": 1781,
"start_col": 2,
"start_line": 1769
} |
Prims.Tot | val va_quick_Vmr (dst src: va_operand_vec_opr) : (va_quickCode unit (va_code_Vmr dst src)) | [
{
"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
}
] | false | 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)) | val va_quick_Vmr (dst src: va_operand_vec_opr) : (va_quickCode unit (va_code_Vmr dst src))
let va_quick_Vmr (dst src: va_operand_vec_opr) : (va_quickCode unit (va_code_Vmr dst src)) = | false | null | false | (va_QProc (va_code_Vmr dst src) ([va_mod_vec_opr dst]) (va_wp_Vmr dst src) (va_wpProof_Vmr dst src)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vmr (dst src: va_operand_vec_opr) : (va_quickCode unit (va_code_Vmr dst src)) | [] | Vale.PPC64LE.InsVector.va_quick_Vmr | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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) | {
"end_col": 9,
"end_line": 59,
"start_col": 2,
"start_line": 58
} |
Prims.Tot | val va_wp_Vcipher
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | let va_wp_Vcipher (dst: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
(Vale.AES.AES_BE_s.mix_columns (Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes
(va_eval_vec_opr va_s0 src1)))) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (()))) | val va_wp_Vcipher
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Vcipher
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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 (Vale.AES.AES_BE_s.mix_columns (Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes
(va_eval_vec_opr va_s0 src1))))
(va_eval_vec_opr va_s0 src2) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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.AES.AES_BE_s.mix_columns",
"Vale.AES.AES_BE_s.shift_rows",
"Vale.AES.AES_common_s.sub_bytes",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig))
//--
//-- Vsbox
val va_code_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsbox : 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_Vsbox 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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (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_Vsbox (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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vsbox : 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_Vsbox dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsbox 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_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vsbox dst src)) =
(va_QProc (va_code_Vsbox dst src) ([va_mod_vec_opr dst]) (va_wp_Vsbox dst src) (va_wpProof_Vsbox
dst src))
//--
//-- RotWord
val va_code_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_RotWord : 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_RotWord 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 /\
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8)))
(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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (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_RotWord (dst: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 /\ (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) ==
8 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = 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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))) ==> va_k va_sM (())))
val va_wpProof_RotWord : dst: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_RotWord dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_RotWord 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_RotWord (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_RotWord dst src1 src2)) =
(va_QProc (va_code_RotWord dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_RotWord dst src1 src2)
(va_wpProof_RotWord dst src1 src2))
//--
//-- Vcipher
val va_code_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipher : 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_Vcipher 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 (Vale.AES.AES_BE_s.mix_columns
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (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_Vcipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vcipher
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vcipher | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 86,
"end_line": 1820,
"start_col": 2,
"start_line": 1816
} |
Prims.Tot | val va_wp_Vpmsumd
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | let va_wp_Vpmsumd (dst: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.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.add (Vale.Math.Poly2_s.mul
(Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_lo (va_eval_vec_opr va_s0
src1))) (Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_lo (va_eval_vec_opr
va_s0 src2)))) (Vale.Math.Poly2_s.mul (Vale.Math.Poly2.Bits_s.of_double32
(Vale.Arch.Types.quad32_double_hi (va_eval_vec_opr va_s0 src1)))
(Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_hi (va_eval_vec_opr va_s0
src2))))) ==> va_k va_sM (()))) | val va_wp_Vpmsumd
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Vpmsumd
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.add (Vale.Math.Poly2_s.mul (Vale.Math.Poly2.Bits_s.of_double32
(Vale.Arch.Types.quad32_double_lo (va_eval_vec_opr va_s0 src1)))
(Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_lo (va_eval_vec_opr
va_s0
src2))))
(Vale.Math.Poly2_s.mul (Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_hi
(va_eval_vec_opr va_s0 src1)))
(Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_hi (va_eval_vec_opr
va_s0
src2))))) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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.Math.Poly2.Bits_s.to_quad32",
"Vale.Math.Poly2_s.add",
"Vale.Math.Poly2_s.mul",
"Vale.Math.Poly2.Bits_s.of_double32",
"Vale.Arch.Types.quad32_double_lo",
"Vale.Arch.Types.quad32_double_hi",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig))
//--
//-- Vsbox
val va_code_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsbox : 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_Vsbox 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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (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_Vsbox (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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vsbox : 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_Vsbox dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsbox 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_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vsbox dst src)) =
(va_QProc (va_code_Vsbox dst src) ([va_mod_vec_opr dst]) (va_wp_Vsbox dst src) (va_wpProof_Vsbox
dst src))
//--
//-- RotWord
val va_code_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_RotWord : 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_RotWord 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 /\
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8)))
(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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (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_RotWord (dst: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 /\ (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) ==
8 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = 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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))) ==> va_k va_sM (())))
val va_wpProof_RotWord : dst: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_RotWord dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_RotWord 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_RotWord (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_RotWord dst src1 src2)) =
(va_QProc (va_code_RotWord dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_RotWord dst src1 src2)
(va_wpProof_RotWord dst src1 src2))
//--
//-- Vcipher
val va_code_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipher : 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_Vcipher 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 (Vale.AES.AES_BE_s.mix_columns
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (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_Vcipher (dst: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
(Vale.AES.AES_BE_s.mix_columns (Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes
(va_eval_vec_opr va_s0 src1)))) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipher : dst: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_Vcipher dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipher 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_Vcipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vcipher dst src1 src2)) =
(va_QProc (va_code_Vcipher dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipher dst src1 src2)
(va_wpProof_Vcipher dst src1 src2))
//--
//-- Vcipherlast
val va_code_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipherlast : 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_Vcipherlast 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 (Vale.AES.AES_BE_s.shift_rows
(Vale.AES.AES_common_s.sub_bytes (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_Vcipherlast (dst: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
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (va_eval_vec_opr va_s0 src1)))
(va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipherlast : dst: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_Vcipherlast dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipherlast 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_Vcipherlast (dst:va_operand_vec_opr) (src1:va_operand_vec_opr)
(src2:va_operand_vec_opr) : (va_quickCode unit (va_code_Vcipherlast dst src1 src2)) =
(va_QProc (va_code_Vcipherlast dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipherlast dst src1
src2) (va_wpProof_Vcipherlast dst src1 src2))
//--
//-- Vncipher
val va_code_Vncipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vncipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vncipher : 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_Vncipher 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.AES.AES_BE_s.inv_mix_columns (Vale.Def.Types_s.quad32_xor
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (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_Vncipher (dst: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.AES.AES_BE_s.inv_mix_columns (Vale.Def.Types_s.quad32_xor
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (va_eval_vec_opr va_s0
src1))) (va_eval_vec_opr va_s0 src2)) ==> va_k va_sM (())))
val va_wpProof_Vncipher : dst: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_Vncipher dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vncipher 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_Vncipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vncipher dst src1 src2)) =
(va_QProc (va_code_Vncipher dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vncipher dst src1 src2)
(va_wpProof_Vncipher dst src1 src2))
//--
//-- Vncipherlast
val va_code_Vncipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vncipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vncipherlast : 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_Vncipherlast 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 (Vale.AES.AES_common_s.inv_sub_bytes
(Vale.AES.AES_BE_s.inv_shift_rows (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_Vncipherlast (dst: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
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (va_eval_vec_opr va_s0
src1))) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vncipherlast : dst: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_Vncipherlast dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vncipherlast 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_Vncipherlast (dst:va_operand_vec_opr) (src1:va_operand_vec_opr)
(src2:va_operand_vec_opr) : (va_quickCode unit (va_code_Vncipherlast dst src1 src2)) =
(va_QProc (va_code_Vncipherlast dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vncipherlast dst
src1 src2) (va_wpProof_Vncipherlast dst src1 src2))
//--
//-- Vpmsumd
val va_code_Vpmsumd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vpmsumd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vpmsumd : 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_Vpmsumd 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.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.add
(Vale.Math.Poly2_s.mul (Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_lo
(va_eval_vec_opr va_s0 src1))) (Vale.Math.Poly2.Bits_s.of_double32
(Vale.Arch.Types.quad32_double_lo (va_eval_vec_opr va_s0 src2)))) (Vale.Math.Poly2_s.mul
(Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_hi (va_eval_vec_opr va_s0
src1))) (Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_hi (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_Vpmsumd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vpmsumd
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vpmsumd | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 35,
"end_line": 1984,
"start_col": 2,
"start_line": 1975
} |
Prims.Tot | val va_quick_Vsldoi (dst src1 src2: va_operand_vec_opr) (count: quad32bytes)
: (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) | [
{
"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
}
] | false | 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)) | 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 src1 src2: va_operand_vec_opr) (count: quad32bytes)
: (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vsldoi (dst src1 src2: va_operand_vec_opr) (count: quad32bytes)
: (va_quickCode unit (va_code_Vsldoi dst src1 src2 count)) | [] | Vale.PPC64LE.InsVector.va_quick_Vsldoi | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 51,
"end_line": 634,
"start_col": 2,
"start_line": 633
} |
Prims.Tot | val va_quick_Vsel (dst src1 src2 sel: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) | [
{
"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
}
] | false | 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)) | 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 src1 src2 sel: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vsel (dst src1 src2 sel: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vsel dst src1 src2 sel)) | [] | Vale.PPC64LE.InsVector.va_quick_Vsel | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 40,
"end_line": 787,
"start_col": 2,
"start_line": 786
} |
Prims.Tot | val va_wp_Vsl
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr 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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vsl
(dst src1 src2: va_operand_vec_opr)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_Vsl | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 74,
"end_line": 504,
"start_col": 2,
"start_line": 484
} |
Prims.Tot | val va_quick_Xxmrghd (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Xxmrghd dst src1 src2)) | [
{
"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
}
] | false | 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)) | 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 src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Xxmrghd dst src1 src2)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Xxmrghd (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Xxmrghd dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Xxmrghd | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 39,
"end_line": 720,
"start_col": 2,
"start_line": 719
} |
Prims.Tot | val va_quick_Vspltisw (dst: va_operand_vec_opr) (src: sim)
: (va_quickCode unit (va_code_Vspltisw dst src)) | [
{
"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
}
] | 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)) | 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)) = | false | null | false | (va_QProc (va_code_Vspltisw dst src)
([va_mod_vec_opr dst])
(va_wp_Vspltisw dst src)
(va_wpProof_Vspltisw dst src)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vspltisw (dst: va_operand_vec_opr) (src: sim)
: (va_quickCode unit (va_code_Vspltisw dst src)) | [] | Vale.PPC64LE.InsVector.va_quick_Vspltisw | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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) | {
"end_col": 34,
"end_line": 893,
"start_col": 2,
"start_line": 892
} |
Prims.Tot | val va_quick_Vspltisb (dst: va_operand_vec_opr) (src: sim)
: (va_quickCode unit (va_code_Vspltisb dst src)) | [
{
"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
}
] | false | 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)) | val va_quick_Vspltisb (dst: va_operand_vec_opr) (src: sim)
: (va_quickCode unit (va_code_Vspltisb dst src))
let va_quick_Vspltisb (dst: va_operand_vec_opr) (src: sim)
: (va_quickCode unit (va_code_Vspltisb dst src)) = | false | null | false | (va_QProc (va_code_Vspltisb dst src)
([va_mod_vec_opr dst])
(va_wp_Vspltisb dst src)
(va_wpProof_Vspltisb dst src)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_Vspltisb",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vspltisb",
"Vale.PPC64LE.InsVector.va_wpProof_Vspltisb",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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 | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vspltisb (dst: va_operand_vec_opr) (src: sim)
: (va_quickCode unit (va_code_Vspltisb dst src)) | [] | Vale.PPC64LE.InsVector.va_quick_Vspltisb | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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_Vspltisb dst src) | {
"end_col": 34,
"end_line": 933,
"start_col": 2,
"start_line": 932
} |
Prims.Tot | 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)) | [
{
"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
}
] | false | 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)) | 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 offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Load128_buffer h dst base offset t)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)) | [] | Vale.PPC64LE.InsVector.va_quick_Load128_buffer | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 15,
"end_line": 988,
"start_col": 2,
"start_line": 986
} |
Prims.Tot | val va_wp_Store128_word4_buffer_index
(h: va_operand_heaplet)
(src: 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 | [
{
"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
}
] | false | 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_wp_Store128_word4_buffer_index
(h: va_operand_heaplet)
(src: 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_Store128_word4_buffer_index
(h: va_operand_heaplet)
(src: 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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_dst_heaplet",
"Vale.PPC64LE.Decls.va_is_src_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_dst_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_heaplet",
"Vale.PPC64LE.Memory.vale_heap",
"Prims.l_imp",
"Vale.PPC64LE.InsVector.buffer128_write",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"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_mem",
"Vale.PPC64LE.Decls.va_upd_operand_heaplet"
] | [] | 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) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Store128_word4_buffer_index
(h: va_operand_heaplet)
(src: 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 | [] | Vale.PPC64LE.InsVector.va_wp_Store128_word4_buffer_index | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
src: 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 | {
"end_col": 34,
"end_line": 1290,
"start_col": 2,
"start_line": 1275
} |
Prims.Tot | val va_quick_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_quickCode unit (va_code_Load128_word4_buffer_index h dst base offset t)) | [
{
"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
}
] | false | 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)) | val va_quick_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_quickCode unit (va_code_Load128_word4_buffer_index h dst base offset t))
let va_quick_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_quickCode unit (va_code_Load128_word4_buffer_index h dst base offset t)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_word4_buffer_index",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Load128_word4_buffer_index",
"Vale.PPC64LE.InsVector.va_wpProof_Load128_word4_buffer_index",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_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_quickCode unit (va_code_Load128_word4_buffer_index h dst base offset t)) | [] | Vale.PPC64LE.InsVector.va_quick_Load128_word4_buffer_index | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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_word4_buffer_index h dst base offset t) | {
"end_col": 72,
"end_line": 1177,
"start_col": 2,
"start_line": 1175
} |
Prims.Tot | val va_quick_Store128_word4_buffer_index
(h: va_operand_heaplet)
(src: va_operand_vec_opr)
(base 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)) | [
{
"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
}
] | false | 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)) | val va_quick_Store128_word4_buffer_index
(h: va_operand_heaplet)
(src: va_operand_vec_opr)
(base 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))
let va_quick_Store128_word4_buffer_index
(h: va_operand_heaplet)
(src: va_operand_vec_opr)
(base 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)) = | false | null | false | (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)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_Store128_word4_buffer_index",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_Mod_mem",
"Vale.PPC64LE.QuickCode.va_mod_heaplet",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Store128_word4_buffer_index",
"Vale.PPC64LE.InsVector.va_wpProof_Store128_word4_buffer_index",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Store128_word4_buffer_index
(h: va_operand_heaplet)
(src: va_operand_vec_opr)
(base 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)) | [] | Vale.PPC64LE.InsVector.va_quick_Store128_word4_buffer_index | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
src: 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_Store128_word4_buffer_index h src base offset t) | {
"end_col": 73,
"end_line": 1306,
"start_col": 2,
"start_line": 1304
} |
Prims.Tot | val va_wp_SHA256_sigma1
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(()))) | val va_wp_SHA256_sigma1
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_SHA256_sigma1
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\
((16 <= t && t < size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\
(forall (va_x_dst: va_value_vec_opr).
let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==>
va_k va_sM (()))) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"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.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Vale.SHA.PPC64LE.SHA_helpers.size_k_w_256",
"Prims.eq2",
"Vale.Def.Words_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_eval_vec_opr",
"Vale.SHA.PPC64LE.SHA_helpers.ws_opaque",
"Prims.op_Subtraction",
"Prims.l_Forall",
"Vale.PPC64LE.Decls.va_value_vec_opr",
"Prims.l_imp",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_0_1_partial",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_operand_vec_opr"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter) | false | true | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_SHA256_sigma1
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.PPC64LE.InsVector.va_wp_SHA256_sigma1 | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src: Vale.PPC64LE.Decls.va_operand_vec_opr ->
t: Vale.SHA.PPC64LE.SHA_helpers.counter ->
block: Vale.SHA.PPC64LE.SHA_helpers.block_w ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 10,
"end_line": 1594,
"start_col": 2,
"start_line": 1590
} |
Prims.Tot | val va_quick_Store128_byte16_buffer_index
(h: va_operand_heaplet)
(src: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Store128_byte16_buffer_index h src base offset t)) | [
{
"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
}
] | false | let va_quick_Store128_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index)) | val va_quick_Store128_byte16_buffer_index
(h: va_operand_heaplet)
(src: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Store128_byte16_buffer_index h src base offset t))
let va_quick_Store128_byte16_buffer_index
(h: va_operand_heaplet)
(src: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Store128_byte16_buffer_index h src base offset t)) = | false | null | false | (va_QProc (va_code_Store128_byte16_buffer_index h src base offset t)
([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"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_Store128_byte16_buffer_index",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_Mod_mem",
"Vale.PPC64LE.QuickCode.va_mod_heaplet",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Store128_byte16_buffer_index",
"Vale.PPC64LE.InsVector.va_wpProof_Store128_byte16_buffer_index",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Store128_byte16_buffer_index
(h: va_operand_heaplet)
(src: va_operand_vec_opr)
(base offset: va_operand_reg_opr)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Store128_byte16_buffer_index h src base offset t)) | [] | Vale.PPC64LE.InsVector.va_quick_Store128_byte16_buffer_index | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: Vale.PPC64LE.Decls.va_operand_heaplet ->
src: 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_Store128_byte16_buffer_index h src base offset t) | {
"end_col": 74,
"end_line": 1532,
"start_col": 2,
"start_line": 1530
} |
Prims.Tot | val va_quick_SHA256_Sigma0
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
: (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) | [
{
"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
}
] | false | let va_quick_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig)) | val va_quick_SHA256_Sigma0
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
: (va_quickCode unit (va_code_SHA256_Sigma0 dst src))
let va_quick_SHA256_Sigma0
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
: (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) = | false | null | false | (va_QProc (va_code_SHA256_Sigma0 dst src)
([va_mod_vec_opr dst])
(va_wp_SHA256_Sigma0 dst src t block hash_orig)
(va_wpProof_SHA256_Sigma0 dst src t block hash_orig)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.SHA.PPC64LE.SHA_helpers.hash256",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_SHA256_Sigma0",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_SHA256_Sigma0",
"Vale.PPC64LE.InsVector.va_wpProof_SHA256_Sigma0",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter) | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_SHA256_Sigma0
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
: (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) | [] | Vale.PPC64LE.InsVector.va_quick_SHA256_Sigma0 | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src: Vale.PPC64LE.Decls.va_operand_vec_opr ->
t: Vale.SHA.PPC64LE.SHA_helpers.counter ->
block: Vale.SHA.PPC64LE.SHA_helpers.block_w ->
hash_orig: Vale.SHA.PPC64LE.SHA_helpers.hash256
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_SHA256_Sigma0 dst src) | {
"end_col": 74,
"end_line": 1650,
"start_col": 2,
"start_line": 1649
} |
Prims.Tot | val va_quick_Vsbox (dst src: va_operand_vec_opr) : (va_quickCode unit (va_code_Vsbox dst src)) | [
{
"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
}
] | false | let va_quick_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vsbox dst src)) =
(va_QProc (va_code_Vsbox dst src) ([va_mod_vec_opr dst]) (va_wp_Vsbox dst src) (va_wpProof_Vsbox
dst src)) | val va_quick_Vsbox (dst src: va_operand_vec_opr) : (va_quickCode unit (va_code_Vsbox dst src))
let va_quick_Vsbox (dst src: va_operand_vec_opr) : (va_quickCode unit (va_code_Vsbox dst src)) = | false | null | false | (va_QProc (va_code_Vsbox dst src)
([va_mod_vec_opr dst])
(va_wp_Vsbox dst src)
(va_wpProof_Vsbox dst src)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vsbox",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vsbox",
"Vale.PPC64LE.InsVector.va_wpProof_Vsbox",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig))
//--
//-- Vsbox
val va_code_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsbox : 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_Vsbox 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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (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_Vsbox (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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vsbox : 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_Vsbox dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsbox 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_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vsbox (dst src: va_operand_vec_opr) : (va_quickCode unit (va_code_Vsbox dst src)) | [] | Vale.PPC64LE.InsVector.va_quick_Vsbox | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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_Vsbox dst src) | {
"end_col": 13,
"end_line": 1739,
"start_col": 2,
"start_line": 1738
} |
Prims.Tot | val va_quick_SHA256_Sigma1
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
: (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) | [
{
"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
}
] | false | let va_quick_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig)) | val va_quick_SHA256_Sigma1
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
: (va_quickCode unit (va_code_SHA256_Sigma1 dst src))
let va_quick_SHA256_Sigma1
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
: (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) = | false | null | false | (va_QProc (va_code_SHA256_Sigma1 dst src)
([va_mod_vec_opr dst])
(va_wp_SHA256_Sigma1 dst src t block hash_orig)
(va_wpProof_SHA256_Sigma1 dst src t block hash_orig)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.SHA.PPC64LE.SHA_helpers.hash256",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_SHA256_Sigma1",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_SHA256_Sigma1",
"Vale.PPC64LE.InsVector.va_wpProof_SHA256_Sigma1",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter) | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_SHA256_Sigma1
(dst src: va_operand_vec_opr)
(t: counter)
(block: block_w)
(hash_orig: hash256)
: (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) | [] | Vale.PPC64LE.InsVector.va_quick_SHA256_Sigma1 | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
src: Vale.PPC64LE.Decls.va_operand_vec_opr ->
t: Vale.SHA.PPC64LE.SHA_helpers.counter ->
block: Vale.SHA.PPC64LE.SHA_helpers.block_w ->
hash_orig: Vale.SHA.PPC64LE.SHA_helpers.hash256
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.PPC64LE.InsVector.va_code_SHA256_Sigma1 dst src) | {
"end_col": 74,
"end_line": 1694,
"start_col": 2,
"start_line": 1693
} |
Prims.Tot | val va_quick_Vncipherlast (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vncipherlast dst src1 src2)) | [
{
"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
}
] | false | let va_quick_Vncipherlast (dst:va_operand_vec_opr) (src1:va_operand_vec_opr)
(src2:va_operand_vec_opr) : (va_quickCode unit (va_code_Vncipherlast dst src1 src2)) =
(va_QProc (va_code_Vncipherlast dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vncipherlast dst
src1 src2) (va_wpProof_Vncipherlast dst src1 src2)) | val va_quick_Vncipherlast (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vncipherlast dst src1 src2))
let va_quick_Vncipherlast (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vncipherlast dst src1 src2)) = | false | null | false | (va_QProc (va_code_Vncipherlast dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Vncipherlast dst src1 src2)
(va_wpProof_Vncipherlast dst src1 src2)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vncipherlast",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vncipherlast",
"Vale.PPC64LE.InsVector.va_wpProof_Vncipherlast",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig))
//--
//-- Vsbox
val va_code_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsbox : 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_Vsbox 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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (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_Vsbox (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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vsbox : 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_Vsbox dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsbox 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_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vsbox dst src)) =
(va_QProc (va_code_Vsbox dst src) ([va_mod_vec_opr dst]) (va_wp_Vsbox dst src) (va_wpProof_Vsbox
dst src))
//--
//-- RotWord
val va_code_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_RotWord : 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_RotWord 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 /\
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8)))
(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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (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_RotWord (dst: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 /\ (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) ==
8 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = 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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))) ==> va_k va_sM (())))
val va_wpProof_RotWord : dst: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_RotWord dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_RotWord 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_RotWord (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_RotWord dst src1 src2)) =
(va_QProc (va_code_RotWord dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_RotWord dst src1 src2)
(va_wpProof_RotWord dst src1 src2))
//--
//-- Vcipher
val va_code_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipher : 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_Vcipher 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 (Vale.AES.AES_BE_s.mix_columns
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (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_Vcipher (dst: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
(Vale.AES.AES_BE_s.mix_columns (Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes
(va_eval_vec_opr va_s0 src1)))) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipher : dst: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_Vcipher dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipher 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_Vcipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vcipher dst src1 src2)) =
(va_QProc (va_code_Vcipher dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipher dst src1 src2)
(va_wpProof_Vcipher dst src1 src2))
//--
//-- Vcipherlast
val va_code_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipherlast : 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_Vcipherlast 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 (Vale.AES.AES_BE_s.shift_rows
(Vale.AES.AES_common_s.sub_bytes (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_Vcipherlast (dst: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
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (va_eval_vec_opr va_s0 src1)))
(va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipherlast : dst: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_Vcipherlast dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipherlast 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_Vcipherlast (dst:va_operand_vec_opr) (src1:va_operand_vec_opr)
(src2:va_operand_vec_opr) : (va_quickCode unit (va_code_Vcipherlast dst src1 src2)) =
(va_QProc (va_code_Vcipherlast dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipherlast dst src1
src2) (va_wpProof_Vcipherlast dst src1 src2))
//--
//-- Vncipher
val va_code_Vncipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vncipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vncipher : 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_Vncipher 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.AES.AES_BE_s.inv_mix_columns (Vale.Def.Types_s.quad32_xor
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (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_Vncipher (dst: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.AES.AES_BE_s.inv_mix_columns (Vale.Def.Types_s.quad32_xor
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (va_eval_vec_opr va_s0
src1))) (va_eval_vec_opr va_s0 src2)) ==> va_k va_sM (())))
val va_wpProof_Vncipher : dst: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_Vncipher dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vncipher 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_Vncipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vncipher dst src1 src2)) =
(va_QProc (va_code_Vncipher dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vncipher dst src1 src2)
(va_wpProof_Vncipher dst src1 src2))
//--
//-- Vncipherlast
val va_code_Vncipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vncipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vncipherlast : 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_Vncipherlast 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 (Vale.AES.AES_common_s.inv_sub_bytes
(Vale.AES.AES_BE_s.inv_shift_rows (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_Vncipherlast (dst: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
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (va_eval_vec_opr va_s0
src1))) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vncipherlast : dst: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_Vncipherlast dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vncipherlast 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_Vncipherlast (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vncipherlast (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vncipherlast dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Vncipherlast | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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_Vncipherlast dst src1 src2) | {
"end_col": 55,
"end_line": 1948,
"start_col": 2,
"start_line": 1947
} |
Prims.Tot | val va_quick_Vpmsumd (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vpmsumd dst src1 src2)) | [
{
"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
}
] | false | let va_quick_Vpmsumd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vpmsumd dst src1 src2)) =
(va_QProc (va_code_Vpmsumd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vpmsumd dst src1 src2)
(va_wpProof_Vpmsumd dst src1 src2)) | val va_quick_Vpmsumd (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vpmsumd dst src1 src2))
let va_quick_Vpmsumd (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vpmsumd dst src1 src2)) = | false | null | false | (va_QProc (va_code_Vpmsumd dst src1 src2)
([va_mod_vec_opr dst])
(va_wp_Vpmsumd dst src1 src2)
(va_wpProof_Vpmsumd dst src1 src2)) | {
"checked_file": "Vale.PPC64LE.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.PPC64LE.InsVector.va_code_Vpmsumd",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_vec_opr",
"Prims.Nil",
"Vale.PPC64LE.InsVector.va_wp_Vpmsumd",
"Vale.PPC64LE.InsVector.va_wpProof_Vpmsumd",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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))))
[@ va_qattr]
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 (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Load128_byte16_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_byte16_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_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_quickCode unit (va_code_Load128_byte16_buffer_index h dst base offset t)) =
(va_QProc (va_code_Load128_byte16_buffer_index h dst base offset t) ([va_mod_vec_opr dst])
(va_wp_Load128_byte16_buffer_index h dst base offset t b index)
(va_wpProof_Load128_byte16_buffer_index h dst base offset t b index))
//--
//-- Store128_byte16_buffer
val va_code_Store128_byte16_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_byte16_buffer : h:va_operand_heaplet -> src:va_operand_vec_opr ->
base:va_operand_reg_opr -> t:taint -> Tot va_pbool
val va_lemma_Store128_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32 (va_eval_vec_opr va_s0 src))
(va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer h src base t)) =
(va_QProc (va_code_Store128_byte16_buffer h src base t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_byte16_buffer h src base t b index) (va_wpProof_Store128_byte16_buffer h src
base t b index))
//--
//-- Store128_byte16_buffer_index
val va_code_Store128_byte16_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_byte16_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_byte16_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_byte16_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.Types_s.reverse_bytes_quad32
(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_byte16_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.Types_s.reverse_bytes_quad32
(va_eval_vec_opr va_s0 src)) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_byte16_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_byte16_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_byte16_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_byte16_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_byte16_buffer_index h src base offset t)) =
(va_QProc (va_code_Store128_byte16_buffer_index h src base offset t) ([va_Mod_mem; va_mod_heaplet
h]) (va_wp_Store128_byte16_buffer_index h src base offset t b index)
(va_wpProof_Store128_byte16_buffer_index h src base offset t b index))
//--
//-- SHA256_sigma0
val va_code_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma0 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15)))
(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).hi3 == sigma_0_0_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 15) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_0_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma0 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma0 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_SHA256_sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma0 dst src)) =
(va_QProc (va_code_SHA256_sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma0 dst src t
block) (va_wpProof_SHA256_sigma0 dst src t block))
//--
//-- SHA256_sigma1
val va_code_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_sigma1 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 /\ ((16 <= t && t < size_k_w_256)) /\
(va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2)))
(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).hi3 == sigma_0_1_partial t block /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (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 /\ ((16 <= t && t
< size_k_w_256)) /\ (va_eval_vec_opr va_s0 src).hi3 == ws_opaque block (t - 2) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
va_get_ok va_sM /\ (va_eval_vec_opr va_sM dst).hi3 == sigma_0_1_partial t block ==> va_k va_sM
(())))
val va_wpProof_SHA256_sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_sigma1 dst src t block va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_sigma1 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_SHA256_sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) : (va_quickCode unit (va_code_SHA256_sigma1 dst src)) =
(va_QProc (va_code_SHA256_sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_sigma1 dst src t
block) (va_wpProof_SHA256_sigma1 dst src t block))
//--
//-- SHA256_Sigma0
val va_code_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma0 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma0 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 0) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma0 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma0 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma0 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_SHA256_Sigma0 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma0 dst src)) =
(va_QProc (va_code_SHA256_Sigma0 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma0 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma0 dst src t block hash_orig))
//--
//-- SHA256_Sigma1
val va_code_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
va_pbool
val va_lemma_SHA256_Sigma1 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
src:va_operand_vec_opr -> t:counter -> block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_SHA256_Sigma1 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 /\ t < size_k_w_256 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4)))
(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__hi3 (va_eval_vec_opr va_sM dst) ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) (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 /\ t <
size_k_w_256 /\ Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src) ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word (Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale t block
hash_orig) 4) /\ (forall (va_x_dst: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__hi3
(va_eval_vec_opr va_sM dst) == Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial t block hash_orig
==> va_k va_sM (())))
val va_wpProof_SHA256_Sigma1 : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> t:counter ->
block:block_w -> hash_orig:hash256 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_SHA256_Sigma1 dst src t block hash_orig va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_SHA256_Sigma1 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_SHA256_Sigma1 (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (t:counter)
(block:block_w) (hash_orig:hash256) : (va_quickCode unit (va_code_SHA256_Sigma1 dst src)) =
(va_QProc (va_code_SHA256_Sigma1 dst src) ([va_mod_vec_opr dst]) (va_wp_SHA256_Sigma1 dst src t
block hash_orig) (va_wpProof_SHA256_Sigma1 dst src t block hash_orig))
//--
//-- Vsbox
val va_code_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vsbox : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vsbox : 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_Vsbox 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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (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_Vsbox (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 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr
va_s0 src))) (Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src))) (Vale.AES.AES_common_s.sub_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src)))
(Vale.AES.AES_common_s.sub_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr
va_s0 src))) ==> va_k va_sM (())))
val va_wpProof_Vsbox : 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_Vsbox dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vsbox 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_Vsbox (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
(va_code_Vsbox dst src)) =
(va_QProc (va_code_Vsbox dst src) ([va_mod_vec_opr dst]) (va_wp_Vsbox dst src) (va_wpProof_Vsbox
dst src))
//--
//-- RotWord
val va_code_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_RotWord : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_RotWord : 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_RotWord 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 /\
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8)))
(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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (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_RotWord (dst: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 /\ (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0 src2) ==
8 /\ Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src2) == 8 /\
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0 src2) == 8) /\ (forall
(va_x_dst:va_value_vec_opr) . let va_sM = 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.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_vec_opr va_s0
src1))) (Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_vec_opr va_s0 src1))) (Vale.AES.AES_BE_s.rot_word
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_vec_opr va_s0 src1)))
(Vale.AES.AES_BE_s.rot_word (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_vec_opr va_s0
src1))) ==> va_k va_sM (())))
val va_wpProof_RotWord : dst: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_RotWord dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_RotWord 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_RotWord (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_RotWord dst src1 src2)) =
(va_QProc (va_code_RotWord dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_RotWord dst src1 src2)
(va_wpProof_RotWord dst src1 src2))
//--
//-- Vcipher
val va_code_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vcipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipher : 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_Vcipher 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 (Vale.AES.AES_BE_s.mix_columns
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (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_Vcipher (dst: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
(Vale.AES.AES_BE_s.mix_columns (Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes
(va_eval_vec_opr va_s0 src1)))) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipher : dst: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_Vcipher dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipher 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_Vcipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) :
(va_quickCode unit (va_code_Vcipher dst src1 src2)) =
(va_QProc (va_code_Vcipher dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipher dst src1 src2)
(va_wpProof_Vcipher dst src1 src2))
//--
//-- Vcipherlast
val va_code_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vcipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vcipherlast : 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_Vcipherlast 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 (Vale.AES.AES_BE_s.shift_rows
(Vale.AES.AES_common_s.sub_bytes (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_Vcipherlast (dst: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
(Vale.AES.AES_BE_s.shift_rows (Vale.AES.AES_common_s.sub_bytes (va_eval_vec_opr va_s0 src1)))
(va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vcipherlast : dst: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_Vcipherlast dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vcipherlast 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_Vcipherlast (dst:va_operand_vec_opr) (src1:va_operand_vec_opr)
(src2:va_operand_vec_opr) : (va_quickCode unit (va_code_Vcipherlast dst src1 src2)) =
(va_QProc (va_code_Vcipherlast dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vcipherlast dst src1
src2) (va_wpProof_Vcipherlast dst src1 src2))
//--
//-- Vncipher
val va_code_Vncipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vncipher : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vncipher : 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_Vncipher 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.AES.AES_BE_s.inv_mix_columns (Vale.Def.Types_s.quad32_xor
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (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_Vncipher (dst: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.AES.AES_BE_s.inv_mix_columns (Vale.Def.Types_s.quad32_xor
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (va_eval_vec_opr va_s0
src1))) (va_eval_vec_opr va_s0 src2)) ==> va_k va_sM (())))
val va_wpProof_Vncipher : dst: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_Vncipher dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vncipher 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_Vncipher (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
: (va_quickCode unit (va_code_Vncipher dst src1 src2)) =
(va_QProc (va_code_Vncipher dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vncipher dst src1 src2)
(va_wpProof_Vncipher dst src1 src2))
//--
//-- Vncipherlast
val va_code_Vncipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_code
val va_codegen_success_Vncipherlast : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vncipherlast : 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_Vncipherlast 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 (Vale.AES.AES_common_s.inv_sub_bytes
(Vale.AES.AES_BE_s.inv_shift_rows (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_Vncipherlast (dst: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
(Vale.AES.AES_common_s.inv_sub_bytes (Vale.AES.AES_BE_s.inv_shift_rows (va_eval_vec_opr va_s0
src1))) (va_eval_vec_opr va_s0 src2) ==> va_k va_sM (())))
val va_wpProof_Vncipherlast : dst: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_Vncipherlast dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vncipherlast 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_Vncipherlast (dst:va_operand_vec_opr) (src1:va_operand_vec_opr)
(src2:va_operand_vec_opr) : (va_quickCode unit (va_code_Vncipherlast dst src1 src2)) =
(va_QProc (va_code_Vncipherlast dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_Vncipherlast dst
src1 src2) (va_wpProof_Vncipherlast dst src1 src2))
//--
//-- Vpmsumd
val va_code_Vpmsumd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
-> Tot va_code
val va_codegen_success_Vpmsumd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
src2:va_operand_vec_opr -> Tot va_pbool
val va_lemma_Vpmsumd : 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_Vpmsumd 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.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.add
(Vale.Math.Poly2_s.mul (Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_lo
(va_eval_vec_opr va_s0 src1))) (Vale.Math.Poly2.Bits_s.of_double32
(Vale.Arch.Types.quad32_double_lo (va_eval_vec_opr va_s0 src2)))) (Vale.Math.Poly2_s.mul
(Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_hi (va_eval_vec_opr va_s0
src1))) (Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_hi (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_Vpmsumd (dst: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.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.add (Vale.Math.Poly2_s.mul
(Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_lo (va_eval_vec_opr va_s0
src1))) (Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_lo (va_eval_vec_opr
va_s0 src2)))) (Vale.Math.Poly2_s.mul (Vale.Math.Poly2.Bits_s.of_double32
(Vale.Arch.Types.quad32_double_hi (va_eval_vec_opr va_s0 src1)))
(Vale.Math.Poly2.Bits_s.of_double32 (Vale.Arch.Types.quad32_double_hi (va_eval_vec_opr va_s0
src2))))) ==> va_k va_sM (())))
val va_wpProof_Vpmsumd : dst: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_Vpmsumd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vpmsumd 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_Vpmsumd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr) : | false | false | Vale.PPC64LE.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Vpmsumd (dst src1 src2: va_operand_vec_opr)
: (va_quickCode unit (va_code_Vpmsumd dst src1 src2)) | [] | Vale.PPC64LE.InsVector.va_quick_Vpmsumd | {
"file_name": "obj/Vale.PPC64LE.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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_Vpmsumd dst src1 src2) | {
"end_col": 39,
"end_line": 1996,
"start_col": 2,
"start_line": 1995
} |
Prims.GTot | val rv_itself_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg -> GTot Type0 | [
{
"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
}
] | false | let rv_itself_inv #a #rst #rg h rv =
V.live h rv /\ V.freeable rv /\
HST.is_eternal_region (V.frameOf 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 = | false | null | false | V.live h rv /\ V.freeable rv /\ HST.is_eternal_region (V.frameOf rv) | {
"checked_file": "LowStar.RVector.fst.checked",
"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"
} | [
"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"
] | [] | (*
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 | false | false | LowStar.RVector.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rv_itself_inv:
#a:Type0 -> #rst:Type -> #rg:regional rst a ->
h:HS.mem -> rv:rvector rg -> GTot Type0 | [] | LowStar.RVector.rv_itself_inv | {
"file_name": "ulib/LowStar.RVector.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | h: FStar.Monotonic.HyperStack.mem -> rv: LowStar.RVector.rvector rg -> Prims.GTot Type0 | {
"end_col": 38,
"end_line": 126,
"start_col": 2,
"start_line": 125
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.