file_name
stringlengths 5
52
| name
stringlengths 4
95
| original_source_type
stringlengths 0
23k
| source_type
stringlengths 9
23k
| source_definition
stringlengths 9
57.9k
| source
dict | source_range
dict | file_context
stringlengths 0
721k
| dependencies
dict | opens_and_abbrevs
listlengths 2
94
| vconfig
dict | interleaved
bool 1
class | verbose_type
stringlengths 1
7.42k
| effect
stringclasses 118
values | effect_flags
sequencelengths 0
2
| mutual_with
sequencelengths 0
11
| ideal_premises
sequencelengths 0
236
| proof_features
sequencelengths 0
1
| is_simple_lemma
bool 2
classes | is_div
bool 2
classes | is_proof
bool 2
classes | is_simply_typed
bool 2
classes | is_type
bool 2
classes | partial_definition
stringlengths 5
3.99k
| completed_definiton
stringlengths 1
1.63M
| isa_cross_project_example
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Steel.Primitive.ForkJoin.fst | Steel.Primitive.ForkJoin.new_thread | val new_thread (p: vprop) : SteelT (thread p) emp (fun _ -> emp) | val new_thread (p: vprop) : SteelT (thread p) emp (fun _ -> emp) | let new_thread (p:vprop)
: SteelT (thread p) emp (fun _ -> emp)
= let r = alloc_pt false in
intro_maybe_p_false p;
intro_exists false (lock_inv_pred r p);
let l = L.new_lock (lock_inv r p) in
let t = {r = r; l = l} in
t | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 5,
"end_line": 59,
"start_col": 0,
"start_line": 52
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module L = Steel.SpinLock
open Steel.FractionalPermission
open Steel.Reference
////////////////////////////////////////////////////////////////////////////////
let maybe_p (p:vprop) (v:bool) = if v then p else emp
[@@__reduce__]
let lock_inv_pred (r:ref bool) (p:vprop) (v:bool) : vprop =
pts_to r full_perm v `star` maybe_p p v
let lock_inv (r:ref bool) (p:vprop)
: vprop
= h_exists (lock_inv_pred r p)
noeq
type thread (p:vprop) = {
r:ref bool;
l:L.lock (lock_inv r p)
}
let intro_maybe_p_false (p:vprop)
: SteelT unit emp (fun _ -> maybe_p p false)
= rewrite_slprop emp (maybe_p p false) (fun _ -> ())
let intro_maybe_p_true (p:vprop)
: SteelT unit p (fun _ -> maybe_p p true)
= rewrite_slprop p (maybe_p p true) (fun _ -> ()) | {
"checked_file": "/",
"dependencies": [
"Steel.SpinLock.fsti.checked",
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Primitive.ForkJoin.fst"
} | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.SpinLock",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: Steel.Effect.Common.vprop -> Steel.Effect.SteelT (Steel.Primitive.ForkJoin.thread p) | Steel.Effect.SteelT | [] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Primitive.ForkJoin.thread",
"Steel.Primitive.ForkJoin.Mkthread",
"Steel.SpinLock.lock",
"Steel.Primitive.ForkJoin.lock_inv",
"Steel.SpinLock.new_lock",
"Prims.unit",
"Steel.Effect.Atomic.intro_exists",
"Prims.bool",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Primitive.ForkJoin.lock_inv_pred",
"Steel.Primitive.ForkJoin.intro_maybe_p_false",
"Steel.Reference.ref",
"Steel.Reference.alloc_pt",
"Steel.Effect.Common.emp"
] | [] | false | true | false | false | false | let new_thread (p: vprop) : SteelT (thread p) emp (fun _ -> emp) =
| let r = alloc_pt false in
intro_maybe_p_false p;
intro_exists false (lock_inv_pred r p);
let l = L.new_lock (lock_inv r p) in
let t = { r = r; l = l } in
t | false |
Vale.AES.AES_s.fst | Vale.AES.AES_s.aes_encrypt | val aes_encrypt (alg: algorithm) (key: aes_key alg) (input: seq16 nat8) : seq16 nat8 | val aes_encrypt (alg: algorithm) (key: aes_key alg) (input: seq16 nat8) : seq16 nat8 | let aes_encrypt (alg:algorithm) (key:aes_key alg) (input:seq16 nat8) : seq16 nat8 =
let key_LE = seq_nat8_to_seq_nat32_LE key in
let input_LE = le_bytes_to_quad32 input in
le_quad32_to_bytes (aes_encrypt_LE alg key_LE input_LE) | {
"file_name": "vale/specs/crypto/Vale.AES.AES_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 57,
"end_line": 116,
"start_col": 0,
"start_line": 113
} | module Vale.AES.AES_s
// IMPORTANT: This specification is written assuming a little-endian mapping from bytes to quad32s
// This is explicit in key_schedule_to_round_keys when we construct the round_key rk,
// but it also applies implicitly to the input quad32
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open FStar.Seq
open FStar.Mul
include Vale.AES.AES_common_s
// operations assume that the quad32 and nat32 values are little-endian interpretations
// of 16-byte and 4-byte sequences
assume val mix_columns_LE (q:quad32) : quad32
assume val inv_mix_columns_LE (q:quad32) : quad32
assume val shift_rows_LE (q:quad32) : quad32
assume val inv_shift_rows_LE (q:quad32) : quad32
assume val rot_word_LE (w:nat32) : nat32
assume val commute_sub_bytes_shift_rows (q:quad32) : Lemma
(sub_bytes (shift_rows_LE q) == shift_rows_LE (sub_bytes q))
assume val commute_rot_word_sub_word (x:nat32) : Lemma
(rot_word_LE (sub_word x) == sub_word (rot_word_LE x))
let is_aes_key_LE (alg:algorithm) (s:seq nat32) : prop0 = length s == nk alg
type aes_key_LE (alg:algorithm) : eqtype = s:(seq nat32){is_aes_key_LE alg s}
let eval_round (state round_key:quad32) =
let s = sub_bytes state in
let s = shift_rows_LE s in
let s = mix_columns_LE s in
let s = quad32_xor s round_key in
s
let rec eval_rounds_def (init:quad32) (round_keys:seq quad32) (n:nat{n < length round_keys}) : quad32 =
if n = 0 then
init
else
eval_round (eval_rounds_def init round_keys (n - 1)) (index round_keys n)
[@"opaque_to_smt"] let eval_rounds = opaque_make eval_rounds_def
irreducible let eval_rounds_reveal = opaque_revealer (`%eval_rounds) eval_rounds eval_rounds_def
let eval_cipher_def (alg:algorithm) (input:quad32) (round_keys:seq quad32) : Pure quad32
(requires length round_keys == nr alg + 1)
(ensures fun _ -> True)
=
let state = quad32_xor input (index round_keys 0) in
let state = eval_rounds_def state round_keys (nr alg - 1) in
let state = sub_bytes state in
let state = shift_rows_LE state in
let state = quad32_xor state (index round_keys (nr alg)) in
state
[@"opaque_to_smt"] let eval_cipher = opaque_make eval_cipher_def
irreducible let eval_cipher_reveal = opaque_revealer (`%eval_cipher) eval_cipher eval_cipher_def
let rec expand_key_def (alg:algorithm) (key:aes_key_LE alg) (size:nat{size <= (nb * ((nr alg) + 1))})
: (ek_LE:seq nat32 {length ek_LE == size}) =
if size = 0 then empty
else
let w = expand_key_def alg key (size - 1) in
let i = size - 1 in
if 0 <= i && i < nk alg then
append w (create 1 (index key i))
else
let temp =
if i % (nk alg) = 0 then
nat32_xor (sub_word (rot_word_LE (index w (i-1)))) (aes_rcon ((i / (nk alg)) - 1))
else if nk alg > 6 && i % (nk alg) = 4 then
sub_word (index w (i - 1))
else
index w (i - 1)
in
append w (create 1 (nat32_xor (index w (i - (nk alg))) temp))
[@"opaque_to_smt"] let expand_key = opaque_make expand_key_def
irreducible let expand_key_reveal = opaque_revealer (`%expand_key) expand_key expand_key_def
let rec key_schedule_to_round_keys (rounds:nat) (w:seq nat32 {length w >= 4 * rounds})
: (round_keys:seq quad32 {length round_keys == rounds}) =
if rounds = 0 then empty
else
let round_keys = key_schedule_to_round_keys (rounds - 1) w in
let rk = Mkfour (index w (4 * rounds - 4)) (index w (4 * rounds - 3)) (index w (4 * rounds - 2)) (index w (4 * rounds - 1)) in
append round_keys (create 1 rk)
[@"opaque_to_smt"]
let key_to_round_keys_LE (alg:algorithm) (key:seq nat32) : Pure (seq quad32)
(requires is_aes_key_LE alg key)
(ensures fun round_keys -> length round_keys == nr alg + 1)
=
key_schedule_to_round_keys (nr alg + 1) (expand_key alg key (nb * (nr alg + 1)))
let aes_encrypt_LE_def (alg:algorithm) (key:seq nat32) (input_LE:quad32) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
eval_cipher_def alg input_LE (key_to_round_keys_LE alg key)
[@"opaque_to_smt"] let aes_encrypt_LE = opaque_make aes_encrypt_LE_def
irreducible let aes_encrypt_LE_reveal = opaque_revealer (`%aes_encrypt_LE) aes_encrypt_LE aes_encrypt_LE_def
#push-options "--z3rlimit 20"
let key_to_round_keys (alg:algorithm) (key:aes_key alg)
: (round_keys:seq nat8 {length round_keys == 16 * (nr alg + 1)}) =
let key_LE = seq_nat8_to_seq_nat32_LE key in
le_seq_quad32_to_bytes (key_to_round_keys_LE alg key_LE)
#pop-options | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_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.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES_s.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.AES.AES_common_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.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
alg: Vale.AES.AES_common_s.algorithm ->
key: Vale.AES.AES_common_s.aes_key alg ->
input: Vale.Def.Words.Seq_s.seq16 Vale.Def.Types_s.nat8
-> Vale.Def.Words.Seq_s.seq16 Vale.Def.Types_s.nat8 | Prims.Tot | [
"total"
] | [] | [
"Vale.AES.AES_common_s.algorithm",
"Vale.AES.AES_common_s.aes_key",
"Vale.Def.Words.Seq_s.seq16",
"Vale.Def.Types_s.nat8",
"Vale.Def.Types_s.le_quad32_to_bytes",
"Vale.AES.AES_s.aes_encrypt_LE",
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.le_bytes_to_quad32",
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat32",
"Vale.Def.Words.Seq_s.seq_nat8_to_seq_nat32_LE"
] | [] | false | false | false | false | false | let aes_encrypt (alg: algorithm) (key: aes_key alg) (input: seq16 nat8) : seq16 nat8 =
| let key_LE = seq_nat8_to_seq_nat32_LE key in
let input_LE = le_bytes_to_quad32 input in
le_quad32_to_bytes (aes_encrypt_LE alg key_LE input_LE) | false |
Vale.AES.AES_s.fst | Vale.AES.AES_s.key_to_round_keys | val key_to_round_keys (alg: algorithm) (key: aes_key alg)
: (round_keys: seq nat8 {length round_keys == 16 * (nr alg + 1)}) | val key_to_round_keys (alg: algorithm) (key: aes_key alg)
: (round_keys: seq nat8 {length round_keys == 16 * (nr alg + 1)}) | let key_to_round_keys (alg:algorithm) (key:aes_key alg)
: (round_keys:seq nat8 {length round_keys == 16 * (nr alg + 1)}) =
let key_LE = seq_nat8_to_seq_nat32_LE key in
le_seq_quad32_to_bytes (key_to_round_keys_LE alg key_LE) | {
"file_name": "vale/specs/crypto/Vale.AES.AES_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 58,
"end_line": 110,
"start_col": 0,
"start_line": 107
} | module Vale.AES.AES_s
// IMPORTANT: This specification is written assuming a little-endian mapping from bytes to quad32s
// This is explicit in key_schedule_to_round_keys when we construct the round_key rk,
// but it also applies implicitly to the input quad32
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open FStar.Seq
open FStar.Mul
include Vale.AES.AES_common_s
// operations assume that the quad32 and nat32 values are little-endian interpretations
// of 16-byte and 4-byte sequences
assume val mix_columns_LE (q:quad32) : quad32
assume val inv_mix_columns_LE (q:quad32) : quad32
assume val shift_rows_LE (q:quad32) : quad32
assume val inv_shift_rows_LE (q:quad32) : quad32
assume val rot_word_LE (w:nat32) : nat32
assume val commute_sub_bytes_shift_rows (q:quad32) : Lemma
(sub_bytes (shift_rows_LE q) == shift_rows_LE (sub_bytes q))
assume val commute_rot_word_sub_word (x:nat32) : Lemma
(rot_word_LE (sub_word x) == sub_word (rot_word_LE x))
let is_aes_key_LE (alg:algorithm) (s:seq nat32) : prop0 = length s == nk alg
type aes_key_LE (alg:algorithm) : eqtype = s:(seq nat32){is_aes_key_LE alg s}
let eval_round (state round_key:quad32) =
let s = sub_bytes state in
let s = shift_rows_LE s in
let s = mix_columns_LE s in
let s = quad32_xor s round_key in
s
let rec eval_rounds_def (init:quad32) (round_keys:seq quad32) (n:nat{n < length round_keys}) : quad32 =
if n = 0 then
init
else
eval_round (eval_rounds_def init round_keys (n - 1)) (index round_keys n)
[@"opaque_to_smt"] let eval_rounds = opaque_make eval_rounds_def
irreducible let eval_rounds_reveal = opaque_revealer (`%eval_rounds) eval_rounds eval_rounds_def
let eval_cipher_def (alg:algorithm) (input:quad32) (round_keys:seq quad32) : Pure quad32
(requires length round_keys == nr alg + 1)
(ensures fun _ -> True)
=
let state = quad32_xor input (index round_keys 0) in
let state = eval_rounds_def state round_keys (nr alg - 1) in
let state = sub_bytes state in
let state = shift_rows_LE state in
let state = quad32_xor state (index round_keys (nr alg)) in
state
[@"opaque_to_smt"] let eval_cipher = opaque_make eval_cipher_def
irreducible let eval_cipher_reveal = opaque_revealer (`%eval_cipher) eval_cipher eval_cipher_def
let rec expand_key_def (alg:algorithm) (key:aes_key_LE alg) (size:nat{size <= (nb * ((nr alg) + 1))})
: (ek_LE:seq nat32 {length ek_LE == size}) =
if size = 0 then empty
else
let w = expand_key_def alg key (size - 1) in
let i = size - 1 in
if 0 <= i && i < nk alg then
append w (create 1 (index key i))
else
let temp =
if i % (nk alg) = 0 then
nat32_xor (sub_word (rot_word_LE (index w (i-1)))) (aes_rcon ((i / (nk alg)) - 1))
else if nk alg > 6 && i % (nk alg) = 4 then
sub_word (index w (i - 1))
else
index w (i - 1)
in
append w (create 1 (nat32_xor (index w (i - (nk alg))) temp))
[@"opaque_to_smt"] let expand_key = opaque_make expand_key_def
irreducible let expand_key_reveal = opaque_revealer (`%expand_key) expand_key expand_key_def
let rec key_schedule_to_round_keys (rounds:nat) (w:seq nat32 {length w >= 4 * rounds})
: (round_keys:seq quad32 {length round_keys == rounds}) =
if rounds = 0 then empty
else
let round_keys = key_schedule_to_round_keys (rounds - 1) w in
let rk = Mkfour (index w (4 * rounds - 4)) (index w (4 * rounds - 3)) (index w (4 * rounds - 2)) (index w (4 * rounds - 1)) in
append round_keys (create 1 rk)
[@"opaque_to_smt"]
let key_to_round_keys_LE (alg:algorithm) (key:seq nat32) : Pure (seq quad32)
(requires is_aes_key_LE alg key)
(ensures fun round_keys -> length round_keys == nr alg + 1)
=
key_schedule_to_round_keys (nr alg + 1) (expand_key alg key (nb * (nr alg + 1)))
let aes_encrypt_LE_def (alg:algorithm) (key:seq nat32) (input_LE:quad32) : Pure quad32
(requires is_aes_key_LE alg key)
(ensures fun _ -> True)
=
eval_cipher_def alg input_LE (key_to_round_keys_LE alg key)
[@"opaque_to_smt"] let aes_encrypt_LE = opaque_make aes_encrypt_LE_def
irreducible let aes_encrypt_LE_reveal = opaque_revealer (`%aes_encrypt_LE) aes_encrypt_LE aes_encrypt_LE_def | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_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.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES_s.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.AES.AES_common_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.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | alg: Vale.AES.AES_common_s.algorithm -> key: Vale.AES.AES_common_s.aes_key alg
-> round_keys:
FStar.Seq.Base.seq Vale.Def.Types_s.nat8
{FStar.Seq.Base.length round_keys == 16 * (Vale.AES.AES_common_s.nr alg + 1)} | Prims.Tot | [
"total"
] | [] | [
"Vale.AES.AES_common_s.algorithm",
"Vale.AES.AES_common_s.aes_key",
"Vale.Def.Types_s.le_seq_quad32_to_bytes",
"Vale.AES.AES_s.key_to_round_keys_LE",
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat32",
"Vale.Def.Words.Seq_s.seq_nat8_to_seq_nat32_LE",
"Vale.Def.Types_s.nat8",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Mul.op_Star",
"Prims.op_Addition",
"Vale.AES.AES_common_s.nr"
] | [] | false | false | false | false | false | let key_to_round_keys (alg: algorithm) (key: aes_key alg)
: (round_keys: seq nat8 {length round_keys == 16 * (nr alg + 1)}) =
| let key_LE = seq_nat8_to_seq_nat32_LE key in
le_seq_quad32_to_bytes (key_to_round_keys_LE alg key_LE) | false |
Steel.ST.GenElim1.fst | Steel.ST.GenElim1.compute_gen_elim_nondep_correct4 | val compute_gen_elim_nondep_correct4 (i0: gen_elim_i) (t1 t2 t3 t4: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4]) | val compute_gen_elim_nondep_correct4 (i0: gen_elim_i) (t1 t2 t3 t4: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4]) | let compute_gen_elim_nondep_correct4
(i0: gen_elim_i)
(t1 t2 t3 t4: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4])
= fun q post intro _ ->
intro _;
rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> q x1 x2 x3 x4 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 (U.raise_val ())))))));
let x1 = elim_exists' () in
let x2 = elim_exists' () in
let x3 = elim_exists' () in
let x4 = elim_exists' () in
let res = Mktuple4 x1 x2 x3 x4 in
elim_pure _;
rewrite_with_trefl (q _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
res | {
"file_name": "lib/steel/Steel.ST.GenElim1.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 7,
"end_line": 542,
"start_col": 0,
"start_line": 528
} | module Steel.ST.GenElim1
let gen_elim_f
(p: vprop)
(a: Type)
(q: (a -> vprop))
(post: (a -> prop))
: Tot Type
= ((opened: inames) -> STGhost a opened p q True post)
module U = FStar.Universe
let gen_unit_elim_t (i: gen_unit_elim_i) : Tot Type =
gen_elim_f (compute_gen_unit_elim_p i) (U.raise_t u#_ u#1 unit) (fun _ -> compute_gen_unit_elim_q i) (fun _ -> compute_gen_unit_elim_post i)
let compute_gen_unit_elim_f_id
(v: vprop)
: Tot (gen_unit_elim_t (GUEId v))
= fun _ -> noop (); U.raise_val ()
let compute_gen_unit_elim_f_pure
(p: prop)
: Tot (gen_unit_elim_t (GUEPure p))
= fun _ ->
rewrite (compute_gen_unit_elim_p (GUEPure p)) (pure p);
elim_pure p;
U.raise_val ()
let compute_gen_unit_elim_f_star
(i1 i2: gen_unit_elim_i)
(f1: gen_unit_elim_t i1)
(f2: gen_unit_elim_t i2)
: Tot (gen_unit_elim_t (GUEStar i1 i2))
= fun _ ->
rewrite (compute_gen_unit_elim_p (GUEStar i1 i2)) (compute_gen_unit_elim_p i1 `star` compute_gen_unit_elim_p i2);
let _ = f1 _ in
let _ = f2 _ in
rewrite (compute_gen_unit_elim_q i1 `star` compute_gen_unit_elim_q i2) (compute_gen_unit_elim_q (GUEStar i1 i2));
U.raise_val ()
let rec compute_gen_unit_elim_f
(i: gen_unit_elim_i)
: GTot (gen_unit_elim_t i)
= match i returns (gen_unit_elim_t i) with
| GUEId v -> compute_gen_unit_elim_f_id v
| GUEPure p -> compute_gen_unit_elim_f_pure p
| GUEStar i1 i2 -> compute_gen_unit_elim_f_star i1 i2 (compute_gen_unit_elim_f i1) (compute_gen_unit_elim_f i2)
let gen_elim_t (i: gen_elim_i) : Tot Type =
gen_elim_f (compute_gen_elim_p i) (compute_gen_elim_a i) (compute_gen_elim_q i) (compute_gen_elim_post i)
let compute_gen_elim_f_unit
(i: gen_unit_elim_i)
: GTot (gen_elim_t (GEUnit i))
= compute_gen_unit_elim_f i
let compute_gen_elim_f_star_l
(i1: gen_elim_i)
(f1: gen_elim_t i1)
(i2: gen_unit_elim_i)
: GTot (gen_elim_t (GEStarL i1 i2))
= let f2 = compute_gen_unit_elim_f i2 in
fun _ ->
rewrite (compute_gen_elim_p (GEStarL i1 i2)) (compute_gen_elim_p i1 `star` compute_gen_unit_elim_p i2);
let res = f1 _ in
let _ = f2 _ in
let res' : compute_gen_elim_a (GEStarL i1 i2) = coerce_with_trefl res in
rewrite (compute_gen_elim_q i1 res `star` compute_gen_unit_elim_q i2) (compute_gen_elim_q (GEStarL i1 i2) res');
res'
let compute_gen_elim_f_star_r
(i1: gen_unit_elim_i)
(i2: gen_elim_i)
(f2: gen_elim_t i2)
: GTot (gen_elim_t (GEStarR i1 i2))
= let f1 = compute_gen_unit_elim_f i1 in
fun _ ->
rewrite (compute_gen_elim_p (GEStarR i1 i2)) (compute_gen_unit_elim_p i1 `star` compute_gen_elim_p i2);
let _ = f1 _ in
let res = f2 _ in
let res' : compute_gen_elim_a (GEStarR i1 i2) = coerce_with_trefl res in
rewrite (compute_gen_unit_elim_q i1 `star` compute_gen_elim_q i2 res) (compute_gen_elim_q (GEStarR i1 i2) res');
res'
let compute_gen_elim_f_star
(i1: gen_elim_i)
(f1: gen_elim_t i1)
(i2: gen_elim_i)
(f2: gen_elim_t i2)
: GTot (gen_elim_t (GEStar i1 i2))
= fun _ ->
rewrite (compute_gen_elim_p (GEStar i1 i2)) (compute_gen_elim_p i1 `star` compute_gen_elim_p i2);
let res1 = f1 _ in
let res2 = f2 _ in
let res : compute_gen_elim_a (GEStar i1 i2) = coerce_with_trefl (res1, res2) in
rewrite (compute_gen_elim_q i1 res1 `star` compute_gen_elim_q i2 res2) (compute_gen_elim_q (GEStar i1 i2) res);
res
let compute_gen_elim_f_exists_no_abs0
(a: Type0)
(body: (a -> vprop))
: GTot (gen_elim_t (GEExistsNoAbs0 body))
= fun _ ->
rewrite (compute_gen_elim_p (GEExistsNoAbs0 body)) (exists_ body);
let gres = elim_exists () in
let res : compute_gen_elim_a (GEExistsNoAbs0 body) = U.raise_val (Ghost.reveal gres) in // coerce_with_trefl (Ghost.reveal gres) in
rewrite (body gres) (compute_gen_elim_q (GEExistsNoAbs0 body) res);
res
let rewrite_with_trefl (#opened:_) (p q:vprop)
: STGhost unit opened
p
(fun _ -> q)
(requires T.with_tactic T.trefl (p == q))
(ensures fun _ -> True)
= rewrite p q
let compute_gen_elim_f_exists_unit0
(a: Type0)
(body: a -> gen_unit_elim_i)
: Tot (gen_elim_t (GEExistsUnit0 body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p (GEExistsUnit0 body)) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
let gres = elim_exists () in
let _ = compute_gen_unit_elim_f (body gres) _ in
let res : compute_gen_elim_a (GEExistsUnit0 body) = U.raise_val (Ghost.reveal gres) in // coerce_with_trefl (Ghost.reveal gres) in
rewrite (compute_gen_unit_elim_q (body gres)) (compute_gen_elim_q (GEExistsUnit0 body) res);
res
let compute_gen_elim_f_exists0
(a: Type0)
(body: a -> gen_elim_i)
(f: (x: a) -> GTot (gen_elim_t (body x)))
: Tot (gen_elim_t (GEExists0 body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p (GEExists0 body)) (exists_ (fun x -> compute_gen_elim_p (body x)));
let gres1 = elim_exists () in
let gres2 = f gres1 _ in
let res : compute_gen_elim_a (GEExists0 body) = coerce_with_trefl (Mkdtuple2 #a #(fun x -> compute_gen_elim_a (body x)) (Ghost.reveal gres1) (Ghost.reveal gres2)) in
rewrite (compute_gen_elim_q (body gres1) gres2) (compute_gen_elim_q (GEExists0 body) res);
res
let compute_gen_elim_f_exists_no_abs1
(a: Type)
(body: (a -> vprop))
: GTot (gen_elim_t (GEExistsNoAbs1 body))
= fun _ ->
rewrite (compute_gen_elim_p (GEExistsNoAbs1 body)) (exists_ body);
let gres = elim_exists () in
let res : compute_gen_elim_a (GEExistsNoAbs1 body) = coerce_with_trefl (Ghost.reveal gres) in
rewrite (body gres) (compute_gen_elim_q (GEExistsNoAbs1 body) res);
res
let compute_gen_elim_f_exists_unit1
(a: Type)
(body: a -> gen_unit_elim_i)
: Tot (gen_elim_t (GEExistsUnit1 body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p (GEExistsUnit1 body)) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
let gres = elim_exists () in
let _ = compute_gen_unit_elim_f (body gres) _ in
let res : compute_gen_elim_a (GEExistsUnit1 body) = coerce_with_trefl (Ghost.reveal gres) in
rewrite (compute_gen_unit_elim_q (body gres)) (compute_gen_elim_q (GEExistsUnit1 body) res);
res
let compute_gen_elim_f_exists1
(a: Type)
(body: a -> gen_elim_i)
(f: (x: a) -> GTot (gen_elim_t (body x)))
: Tot (gen_elim_t (GEExists1 body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p (GEExists1 body)) (exists_ (fun x -> compute_gen_elim_p (body x)));
let gres1 = elim_exists () in
let gres2 = f gres1 _ in
let res : compute_gen_elim_a (GEExists1 body) = coerce_with_trefl (Mkdtuple2 #a #(fun x -> compute_gen_elim_a (body x)) (Ghost.reveal gres1) (Ghost.reveal gres2)) in
rewrite (compute_gen_elim_q (body gres1) gres2) (compute_gen_elim_q (GEExists1 body) res);
res
let rec compute_gen_elim_f
(i: gen_elim_i)
: GTot (gen_elim_t i)
= match i returns (gen_elim_t i) with
| GEUnit i -> compute_gen_elim_f_unit i
| GEStarL i1 i2 -> compute_gen_elim_f_star_l i1 (compute_gen_elim_f i1) i2
| GEStarR i1 i2 -> compute_gen_elim_f_star_r i1 i2 (compute_gen_elim_f i2)
| GEStar i1 i2 -> compute_gen_elim_f_star i1 (compute_gen_elim_f i1) i2 (compute_gen_elim_f i2)
| GEExistsNoAbs0 body -> compute_gen_elim_f_exists_no_abs0 _ body
| GEExistsUnit0 body -> compute_gen_elim_f_exists_unit0 _ body
| GEExists0 body -> compute_gen_elim_f_exists0 _ body (fun x -> compute_gen_elim_f (body x))
| GEExistsNoAbs1 body -> compute_gen_elim_f_exists_no_abs1 _ body
| GEExistsUnit1 body -> compute_gen_elim_f_exists_unit1 _ body
| GEExists1 body -> compute_gen_elim_f_exists1 _ body (fun x -> compute_gen_elim_f (body x))
let rec tele_p (x: gen_elim_tele) : Tot vprop =
match x with
| TRet v p -> v `star` pure p
| TExists ty body -> exists_ (fun x -> tele_p (body x))
let elim_exists' (#a:Type)
(#opened_invariants:_)
(#p:a -> vprop)
(_:unit)
: STGhostT (a) opened_invariants
(exists_ p)
(fun x -> p x)
= let gx = elim_exists () in
let x = Ghost.reveal gx in
rewrite (p gx) (p x);
x
let vprop_rewrite (from to: vprop) : Tot Type =
gen_elim_f from unit (fun _ -> to) (fun _ -> True)
let tele_star_vprop_correct_ret
(v': vprop) (p': prop) (v: vprop) (p: prop)
: Tot (vprop_rewrite (tele_p (TRet v' p') `star` v `star` pure p) (tele_p (tele_star_vprop (TRet v' p') v p)))
= fun _ ->
elim_pure p;
rewrite (tele_p _) (v' `star` pure p');
elim_pure p';
intro_pure (p /\ p');
rewrite ((v `star` v') `star` pure (p /\ p')) (tele_p _)
let tele_star_vprop_correct_exists
(v: vprop) (p: prop)
(ty: _) (body: ty -> gen_elim_tele) (ih: (x: ty) -> GTot (vprop_rewrite (tele_p (body x) `star` v `star` pure p) (tele_p (tele_star_vprop (body x) v p))))
: Tot (vprop_rewrite (tele_p (TExists ty body) `star` v `star` pure p) (tele_p (tele_star_vprop (TExists ty body) v p)))
= fun _ ->
rewrite_with_trefl (tele_p _) (exists_ (fun x -> tele_p (body x)));
let x = elim_exists' () in
ih x _;
intro_exists x (fun x -> tele_p (tele_star_vprop (body x) v p));
rewrite_with_trefl (exists_ (fun x -> tele_p (tele_star_vprop (body x) v p))) (tele_p _)
let rec tele_star_vprop_correct
(i: gen_elim_tele) (v: vprop) (p: prop)
: GTot (vprop_rewrite
(tele_p i `star` v `star` pure p)
(tele_p (tele_star_vprop i v p))
)
= match i returns vprop_rewrite
(tele_p i `star` v `star` pure p)
(tele_p (tele_star_vprop i v p)) with
| TRet v' p' -> tele_star_vprop_correct_ret v' p' v p
| TExists ty body -> tele_star_vprop_correct_exists v p ty body (fun x -> tele_star_vprop_correct (body x) v p)
let tele_star_correct_ret_l
(v1: vprop) (p1: prop) (i2: gen_elim_tele)
: Tot (vprop_rewrite (tele_p (TRet v1 p1) `star` tele_p i2) (tele_p (TRet v1 p1 `tele_star` i2)))
= fun _ ->
rewrite (tele_p (TRet v1 p1)) (v1 `star` pure p1);
tele_star_vprop_correct i2 v1 p1 _;
rewrite (tele_p _) (tele_p _)
let tele_star_correct_ret_r
(i1: gen_elim_tele { ~ (TRet? i1) }) (v2: vprop) (p2: prop)
: Tot (vprop_rewrite (tele_p i1 `star` tele_p (TRet v2 p2)) (tele_p (i1 `tele_star` TRet v2 p2)))
= fun _ ->
rewrite (tele_p (TRet v2 p2)) (v2 `star` pure p2);
tele_star_vprop_correct i1 v2 p2 _;
rewrite (tele_p _) (tele_p (i1 `tele_star` TRet v2 p2))
let tele_star_correct_exists
(ty1: _) (f1: ty1 -> gen_elim_tele) (ty2: _) (f2: ty2 -> gen_elim_tele)
(ih: (x1: ty1) -> (x2: ty2) -> GTot (vprop_rewrite (tele_p (f1 x1) `star` tele_p (f2 x2)) (tele_p (f1 x1 `tele_star` f2 x2))))
: Tot (vprop_rewrite (tele_p (TExists ty1 f1) `star` tele_p (TExists ty2 f2)) (tele_p (tele_star (TExists ty1 f1) (TExists ty2 f2))))
= fun _ ->
rewrite_with_trefl (tele_p (TExists ty1 f1)) (exists_ (fun x1 -> tele_p (f1 x1)));
let x1 = elim_exists' () in
rewrite_with_trefl (tele_p (TExists ty2 f2)) (exists_ (fun x2 -> tele_p (f2 x2)));
let x2 = elim_exists' () in
ih x1 x2 _;
intro_exists x2 (fun x2 -> tele_p (tele_star (f1 x1) (f2 x2)));
intro_exists x1 (fun x1 -> exists_ (fun x2 -> tele_p (tele_star (f1 x1) (f2 x2))));
rewrite_with_trefl (exists_ _) (tele_p _)
let rec tele_star_correct
(i1 i2: gen_elim_tele)
: GTot (vprop_rewrite (tele_p i1 `star` tele_p i2) (tele_p (i1 `tele_star` i2)))
= match i1 returns vprop_rewrite (tele_p i1 `star` tele_p i2) (tele_p (i1 `tele_star` i2)) with
| TRet v1 p1 -> tele_star_correct_ret_l v1 p1 i2
| TExists ty1 f1 ->
begin match i2 returns vprop_rewrite (tele_p (TExists ty1 f1) `star` tele_p i2) (tele_p (TExists ty1 f1 `tele_star` i2)) with
| TRet v2 p2 -> tele_star_correct_ret_r (TExists ty1 f1) v2 p2
| TExists ty2 f2 -> tele_star_correct_exists ty1 f1 ty2 f2 (fun x1 x2 -> tele_star_correct (f1 x1) (f2 x2))
end
[@@noextract_to "Plugin" ]
let ge_to_tele_t
(i: gen_elim_i)
: Tot Type
= vprop_rewrite (compute_gen_elim_p i) (tele_p (compute_gen_elim_tele i))
let compute_gen_elim_tele_correct_unit
(v: gen_unit_elim_i)
: Tot (ge_to_tele_t (GEUnit v))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (compute_gen_unit_elim_p v);
let _ = compute_gen_unit_elim_f v _ in
intro_pure (compute_gen_unit_elim_post v);
rewrite_with_trefl (compute_gen_unit_elim_q v `star` pure _) (tele_p _)
let compute_gen_elim_tele_correct_star_l
(l: gen_elim_i)
(ihl: ge_to_tele_t l)
(ru: gen_unit_elim_i)
: Tot (ge_to_tele_t (GEStarL l ru))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (compute_gen_elim_p l `star` compute_gen_unit_elim_p ru);
ihl _;
let _ = compute_gen_unit_elim_f ru _ in
intro_pure (compute_gen_unit_elim_post ru);
tele_star_vprop_correct _ _ _ _;
rewrite_with_trefl (tele_p _) (tele_p _)
let compute_gen_elim_tele_correct_star_r
(lu: gen_unit_elim_i)
(r: gen_elim_i)
(ihr: ge_to_tele_t r)
: Tot (ge_to_tele_t (GEStarR lu r))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (compute_gen_unit_elim_p lu `star` compute_gen_elim_p r);
ihr _;
let _ = compute_gen_unit_elim_f lu _ in
intro_pure (compute_gen_unit_elim_post lu);
tele_star_vprop_correct _ _ _ _;
rewrite_with_trefl (tele_p _) (tele_p _)
let compute_gen_elim_tele_correct_star
(l: gen_elim_i)
(ihl: ge_to_tele_t l)
(r: gen_elim_i)
(ihr: ge_to_tele_t r)
: Tot (ge_to_tele_t (GEStar l r))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (compute_gen_elim_p l `star` compute_gen_elim_p r);
ihl _;
ihr _;
tele_star_correct (compute_gen_elim_tele l) (compute_gen_elim_tele r) _;
rewrite_with_trefl (tele_p _) (tele_p _)
let compute_gen_elim_tele_correct_exists_no_abs0
(ty: _)
(body: ty -> vprop)
: Tot (ge_to_tele_t (GEExistsNoAbs0 #ty body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (exists_ body);
let x = elim_exists' () in
intro_pure True;
rewrite (body x) (body (U.downgrade_val (U.raise_val x)));
intro_exists (U.raise_val u#0 u#1 x) (fun x -> body (U.downgrade_val x) `star` pure True);
rewrite_with_trefl (exists_ _) (tele_p _)
let compute_gen_elim_tele_correct_exists_unit0
(ty: _)
(body: ty -> gen_unit_elim_i)
: Tot (ge_to_tele_t (GEExistsUnit0 #ty body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
let x = elim_exists' () in
let _ = compute_gen_unit_elim_f (body x) _ in
intro_pure (compute_gen_unit_elim_post (body (U.downgrade_val (U.raise_val u#0 u#1 x))));
rewrite (compute_gen_unit_elim_q (body x)) (compute_gen_unit_elim_q (body (U.downgrade_val (U.raise_val x))));
intro_exists (U.raise_val u#0 u#1 x) (fun x -> compute_gen_unit_elim_q (body (U.downgrade_val x)) `star` pure (compute_gen_unit_elim_post (body (U.downgrade_val x))));
rewrite_with_trefl (exists_ _) (tele_p _)
let compute_gen_elim_tele_correct_exists0
(ty: _)
(body: ty -> gen_elim_i)
(ih: (x: ty) -> GTot (ge_to_tele_t (body x)))
: Tot (ge_to_tele_t (GEExists0 #ty body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_elim_p (body x)));
let x = elim_exists' () in
ih x _;
rewrite (tele_p (compute_gen_elim_tele (body x))) (tele_p (compute_gen_elim_tele (body (U.downgrade_val (U.raise_val u#0 u#1 x)))));
intro_exists (U.raise_val u#0 u#1 x) (fun x -> tele_p (compute_gen_elim_tele (body (U.downgrade_val u#0 u#1 x))));
rewrite_with_trefl (exists_ _) (tele_p _)
let compute_gen_elim_tele_correct_exists_no_abs1
(ty: _)
(body: ty -> vprop)
: Tot (ge_to_tele_t (GEExistsNoAbs1 #ty body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (exists_ body);
let x = elim_exists' () in
intro_pure True;
intro_exists x (fun x -> body x `star` pure True);
rewrite_with_trefl (exists_ _) (tele_p _)
let compute_gen_elim_tele_correct_exists_unit1
(ty: _)
(body: ty -> gen_unit_elim_i)
: Tot (ge_to_tele_t (GEExistsUnit1 #ty body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
let x = elim_exists' () in
let _ = compute_gen_unit_elim_f (body x) _ in
intro_pure (compute_gen_unit_elim_post (body x));
intro_exists x (fun x -> compute_gen_unit_elim_q (body x) `star` pure (compute_gen_unit_elim_post (body x)));
rewrite_with_trefl (exists_ _) (tele_p _)
let compute_gen_elim_tele_correct_exists1
(ty: _)
(body: ty -> gen_elim_i)
(ih: (x: ty) -> GTot (ge_to_tele_t (body x)))
: Tot (ge_to_tele_t (GEExists1 #ty body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_elim_p (body x)));
let x = elim_exists' () in
ih x _;
intro_exists x (fun x -> tele_p (compute_gen_elim_tele (body x)));
rewrite_with_trefl (exists_ _) (tele_p _)
let rec compute_gen_elim_tele_correct
(x: gen_elim_i)
: GTot (ge_to_tele_t x)
= match x returns ge_to_tele_t x with
| GEUnit v -> compute_gen_elim_tele_correct_unit v
| GEStarL l ru -> compute_gen_elim_tele_correct_star_l l (compute_gen_elim_tele_correct l) ru
| GEStarR lu r -> compute_gen_elim_tele_correct_star_r lu r (compute_gen_elim_tele_correct r)
| GEStar l r -> compute_gen_elim_tele_correct_star l (compute_gen_elim_tele_correct l) r (compute_gen_elim_tele_correct r)
| GEExistsNoAbs0 #ty body -> compute_gen_elim_tele_correct_exists_no_abs0 ty body
| GEExistsUnit0 #ty body -> compute_gen_elim_tele_correct_exists_unit0 ty body
| GEExists0 #ty body -> compute_gen_elim_tele_correct_exists0 ty body (fun x -> compute_gen_elim_tele_correct (body x))
| GEExistsNoAbs1 #ty body -> compute_gen_elim_tele_correct_exists_no_abs1 ty body
| GEExistsUnit1 #ty body -> compute_gen_elim_tele_correct_exists_unit1 ty body
| GEExists1 #ty body -> compute_gen_elim_tele_correct_exists1 ty body (fun x -> compute_gen_elim_tele_correct (body x))
let rec gen_elim_nondep_p (ty: list (Type u#a)) : Tot (curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> vprop) -> curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> prop) -> Tot vprop) =
match ty as ty' returns curried_function_type ty' (U.raise_t u#_ u#(max 2 a) unit -> vprop) -> curried_function_type ty' (U.raise_t u#_ u#(max 2 a) unit -> prop) -> Tot vprop with
| [] -> fun q post -> q (U.raise_val ()) `star` pure (post (U.raise_val ()))
| t :: tq -> fun q post -> exists_ (fun x -> gen_elim_nondep_p tq (q x) (post x))
let rec gen_elim_nondep_sem_correct
(ty: list (Type u#a))
: Tot ((q: curried_function_type ty _) -> (post: curried_function_type ty _) -> Lemma
(tele_p (gen_elim_nondep_sem ty q post) `equiv` gen_elim_nondep_p ty q post)
)
= match ty returns ((q: curried_function_type ty _) -> (post: curried_function_type ty _) -> Lemma
(tele_p (gen_elim_nondep_sem ty q post) `equiv` gen_elim_nondep_p ty q post)
)
with
| [] -> fun q post -> equiv_refl (q (U.raise_val ()) `star` pure (post (U.raise_val ())))
| ta :: tq -> fun q post ->
let phi
(x: ta)
: Lemma
(tele_p (gen_elim_nondep_sem tq (q x) (post x)) `equiv` gen_elim_nondep_p tq (q x) (post x))
= gen_elim_nondep_sem_correct tq (q x) (post x)
in
Classical.forall_intro phi;
let prf () : Lemma
(exists_ (fun x -> tele_p (gen_elim_nondep_sem tq (q x) (post x))) `equiv` exists_ (fun x -> gen_elim_nondep_p tq (q x) (post x)))
=
exists_equiv (fun x -> tele_p (gen_elim_nondep_sem tq (q x) (post x))) (fun x -> gen_elim_nondep_p tq (q x) (post x))
in
assert_norm (tele_p (gen_elim_nondep_sem (ta :: tq) q post) == exists_ (fun x -> tele_p (gen_elim_nondep_sem tq (q x) (post x))));
assert_norm (gen_elim_nondep_p (ta :: tq) q post == exists_ (fun x -> gen_elim_nondep_p tq (q x) (post x)));
prf ()
let compute_gen_elim_nondep_correct_t
(i0: gen_elim_i)
(ty: list (Type u#1))
: Tot Type
= (q: _) ->
(post: _) ->
(intro: vprop_rewrite (compute_gen_elim_p i0) (gen_elim_nondep_p ty q post)) ->
GTot (gen_elim_f
(compute_gen_elim_p i0)
(compute_gen_elim_nondep_a' ty)
(fun x -> compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) ty q x (U.raise_val ()))
(fun x -> compute_uncurry _ (fun _ -> True) ty post x (U.raise_val ()))
)
let compute_gen_elim_nondep_correct0
(i0: gen_elim_i)
: Tot (compute_gen_elim_nondep_correct_t i0 [])
= fun q post intro _ ->
intro _;
rewrite_with_trefl (gen_elim_nondep_p _ _ _) (q (U.raise_val ()) `star` pure (post (U.raise_val ())));
let res = U.raise_val () in
elim_pure _;
rewrite_with_trefl (q (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
res
let compute_gen_elim_nondep_correct1
(i0: gen_elim_i)
(t1: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1])
= fun q post intro _ ->
intro _;
rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> q x1 (U.raise_val ()) `star` pure (post x1 (U.raise_val ()))));
let res = elim_exists' () in
elim_pure _;
rewrite_with_trefl (q _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
res
let compute_gen_elim_nondep_correct2
(i0: gen_elim_i)
(t1 t2: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2])
= fun q post intro _ ->
intro _;
rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> q x1 x2 (U.raise_val ()) `star` pure (post x1 x2 (U.raise_val ())))));
let x1 = elim_exists' () in
let x2 = elim_exists' () in
let res = Mktuple2 x1 x2 in
elim_pure _;
rewrite_with_trefl (q _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
res
let compute_gen_elim_nondep_correct3
(i0: gen_elim_i)
(t1 t2 t3: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3])
= fun q post intro _ ->
intro _;
rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> q x1 x2 x3 (U.raise_val ()) `star` pure (post x1 x2 x3 (U.raise_val ()))))));
let x1 = elim_exists' () in
let x2 = elim_exists' () in
let x3 = elim_exists' () in
let res = Mktuple3 x1 x2 x3 in
elim_pure _;
rewrite_with_trefl (q _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
res | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.GenElim1.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.ST.GenElim1.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | i0: Steel.ST.GenElim1.Base.gen_elim_i -> t1: Type -> t2: Type -> t3: Type -> t4: Type
-> Steel.ST.GenElim1.compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4] | Prims.Tot | [
"total"
] | [] | [
"Steel.ST.GenElim1.Base.gen_elim_i",
"Steel.ST.GenElim1.Base.curried_function_type",
"Prims.Cons",
"Prims.Nil",
"FStar.Universe.raise_t",
"Prims.unit",
"Steel.Effect.Common.vprop",
"Prims.prop",
"Steel.ST.GenElim1.vprop_rewrite",
"Steel.ST.GenElim1.Base.compute_gen_elim_p",
"Steel.ST.GenElim1.gen_elim_nondep_p",
"Steel.Memory.inames",
"Steel.ST.GenElim1.Base.compute_gen_elim_nondep_a'",
"Steel.ST.GenElim1.rewrite_with_trefl",
"FStar.Universe.raise_val",
"Steel.ST.GenElim1.Base.compute_uncurry",
"Steel.ST.GenElim1.Base.compute_gen_elim_p'",
"Steel.ST.Util.elim_pure",
"FStar.Pervasives.Native.tuple4",
"FStar.Pervasives.Native.Mktuple4",
"Steel.ST.GenElim1.elim_exists'",
"Steel.Effect.Common.VStar",
"Steel.ST.Util.pure",
"Steel.ST.Util.exists_",
"Steel.Effect.Common.star",
"Steel.ST.GenElim1.compute_gen_elim_nondep_correct_t"
] | [] | false | false | false | false | false | let compute_gen_elim_nondep_correct4 (i0: gen_elim_i) (t1 t2 t3 t4: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4]) =
| fun q post intro _ ->
intro _;
rewrite_with_trefl (gen_elim_nondep_p _ _ _)
(exists_ (fun x1 ->
exists_ (fun x2 ->
exists_ (fun x3 ->
exists_ (fun x4 ->
(q x1 x2 x3 x4 (U.raise_val ()))
`star`
(pure (post x1 x2 x3 x4 (U.raise_val ()))))))));
let x1 = elim_exists' () in
let x2 = elim_exists' () in
let x3 = elim_exists' () in
let x4 = elim_exists' () in
let res = Mktuple4 x1 x2 x3 x4 in
elim_pure _;
rewrite_with_trefl (q _ _ _ _ (U.raise_val ()))
(compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
res | false |
Vale.Wrapper.X64.AEShash.fsti | Vale.Wrapper.X64.AEShash.uint8_p | val uint8_p : Type0 | let uint8_p = B.buffer UInt8.t | {
"file_name": "vale/code/arch/x64/interop/Vale.Wrapper.X64.AEShash.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 18,
"start_col": 0,
"start_line": 18
} | module Vale.Wrapper.X64.AEShash
open Vale.X64.CPU_Features_s
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.AES.AES_s
open Vale.Interop.Base
open Vale.Def.Types_s
open Vale.AES.OptPublic | {
"checked_file": "/",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Wrapper.X64.AES.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.AES.OptPublic.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Up.fsti.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Wrapper.X64.AEShash.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.AES.OptPublic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_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": true,
"full_module": "LowStar.BufferView.Up",
"short_module": "UV"
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Wrapper.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Wrapper.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t"
] | [] | false | false | false | true | true | let uint8_p =
| B.buffer UInt8.t | false |
|
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Mem128_lemma | val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code | val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code | let va_code_Mem128_lemma () =
(va_Block (va_CNil ())) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 19,
"start_col": 0,
"start_line": 18
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | va_dummy: Prims.unit -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CNil",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Mem128_lemma () =
| (va_Block (va_CNil ())) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Paddd | val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | let va_codegen_success_Paddd dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 55,
"start_col": 0,
"start_line": 54
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Paddd dst src =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Mem128_lemma | val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool | val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool | let va_codegen_success_Mem128_lemma () =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 23,
"start_col": 0,
"start_line": 22
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ())) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | va_dummy: Prims.unit -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Mem128_lemma () =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_VPaddd | val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool | val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool | let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 86,
"start_col": 0,
"start_line": 85
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_VPaddd dst src1 src2 =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Pxor | val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | let va_codegen_success_Pxor dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 117,
"start_col": 0,
"start_line": 116
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Pxor dst src =
| (va_ttrue ()) | false |
Vale.Wrapper.X64.AEShash.fsti | Vale.Wrapper.X64.AEShash.keyhash_init_st | val keyhash_init_st : a:
Vale.AES.AES_common_s.algorithm
{a = Vale.AES.AES_common_s.AES_128 \/ a = Vale.AES.AES_common_s.AES_256}
-> Type0 | let keyhash_init_st (a: algorithm { a = AES_128 \/ a = AES_256 }) =
key:Ghost.erased (Seq.seq nat32) ->
roundkeys_b:uint8_p ->
hkeys_b:uint8_p ->
Stack unit
(requires fun h0 ->
B.disjoint roundkeys_b hkeys_b /\
B.live h0 roundkeys_b /\ B.live h0 hkeys_b /\
B.length roundkeys_b = Vale.Wrapper.X64.AES.key_offset a /\
B.length hkeys_b = 128 /\
is_aes_key_LE a (Ghost.reveal key) /\
(Seq.equal (B.as_seq h0 roundkeys_b)
(seq_nat8_to_seq_uint8 (le_seq_quad32_to_bytes (key_to_round_keys_LE a (Ghost.reveal key))))) /\
aesni_enabled /\ pclmulqdq_enabled /\ avx_enabled /\ sse_enabled)
(ensures fun h0 _ h1 ->
B.modifies (B.loc_buffer hkeys_b) h0 h1 /\
hkeys_reqs_pub (le_bytes_to_seq_quad32 (seq_uint8_to_seq_nat8 (B.as_seq h1 hkeys_b)))
(reverse_bytes_quad32 (aes_encrypt_LE a (Ghost.reveal key) (Mkfour 0 0 0 0)))) | {
"file_name": "vale/code/arch/x64/interop/Vale.Wrapper.X64.AEShash.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 86,
"end_line": 42,
"start_col": 0,
"start_line": 20
} | module Vale.Wrapper.X64.AEShash
open Vale.X64.CPU_Features_s
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.AES.AES_s
open Vale.Interop.Base
open Vale.Def.Types_s
open Vale.AES.OptPublic
unfold
let uint8_p = B.buffer UInt8.t | {
"checked_file": "/",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Wrapper.X64.AES.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.AES.OptPublic.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Up.fsti.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Wrapper.X64.AEShash.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.AES.OptPublic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_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": true,
"full_module": "LowStar.BufferView.Up",
"short_module": "UV"
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Wrapper.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Wrapper.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a:
Vale.AES.AES_common_s.algorithm
{a = Vale.AES.AES_common_s.AES_128 \/ a = Vale.AES.AES_common_s.AES_256}
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.AES.AES_common_s.algorithm",
"Prims.l_or",
"Prims.b2t",
"Prims.op_Equality",
"Vale.AES.AES_common_s.AES_128",
"Vale.AES.AES_common_s.AES_256",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.Wrapper.X64.AEShash.uint8_p",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"LowStar.Monotonic.Buffer.disjoint",
"FStar.UInt8.t",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.live",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"Vale.Wrapper.X64.AES.key_offset",
"Vale.AES.AES_s.is_aes_key_LE",
"FStar.Ghost.reveal",
"FStar.Seq.Base.equal",
"LowStar.Monotonic.Buffer.as_seq",
"Vale.Def.Words.Seq_s.seq_nat8_to_seq_uint8",
"Vale.Def.Types_s.le_seq_quad32_to_bytes",
"Vale.AES.AES_s.key_to_round_keys_LE",
"Vale.X64.CPU_Features_s.aesni_enabled",
"Vale.X64.CPU_Features_s.pclmulqdq_enabled",
"Vale.X64.CPU_Features_s.avx_enabled",
"Vale.X64.CPU_Features_s.sse_enabled",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_buffer",
"Vale.AES.OptPublic.hkeys_reqs_pub",
"Vale.Def.Types_s.le_bytes_to_seq_quad32",
"Vale.Def.Words.Seq_s.seq_uint8_to_seq_nat8",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.AES.AES_s.aes_encrypt_LE",
"Vale.Def.Words_s.Mkfour"
] | [] | false | false | false | false | true | let keyhash_init_st (a: algorithm{a = AES_128 \/ a = AES_256}) =
| key: Ghost.erased (Seq.seq nat32) -> roundkeys_b: uint8_p -> hkeys_b: uint8_p
-> Stack unit
(requires
fun h0 ->
B.disjoint roundkeys_b hkeys_b /\ B.live h0 roundkeys_b /\ B.live h0 hkeys_b /\
B.length roundkeys_b = Vale.Wrapper.X64.AES.key_offset a /\ B.length hkeys_b = 128 /\
is_aes_key_LE a (Ghost.reveal key) /\
(Seq.equal (B.as_seq h0 roundkeys_b)
(seq_nat8_to_seq_uint8 (le_seq_quad32_to_bytes (key_to_round_keys_LE a
(Ghost.reveal key))))) /\ aesni_enabled /\ pclmulqdq_enabled /\
avx_enabled /\ sse_enabled)
(ensures
fun h0 _ h1 ->
B.modifies (B.loc_buffer hkeys_b) h0 h1 /\
hkeys_reqs_pub (le_bytes_to_seq_quad32 (seq_uint8_to_seq_nat8 (B.as_seq h1 hkeys_b)))
(reverse_bytes_quad32 (aes_encrypt_LE a (Ghost.reveal key) (Mkfour 0 0 0 0)))) | false |
|
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Pand | val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool | val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool | let va_codegen_success_Pand dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 149,
"start_col": 0,
"start_line": 148
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_opr128
-> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr128",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Pand dst src =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_VPxor | val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool | val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool | let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 178,
"start_col": 0,
"start_line": 177
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2)) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_opr128
-> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr128",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_VPxor dst src1 src2 =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_VPaddd | val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code | val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code | let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 73,
"end_line": 82,
"start_col": 0,
"start_line": 81
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_VPaddd",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_VPaddd dst src1 src2 =
| (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Pslld | val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool | val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool | let va_codegen_success_Pslld dst amt =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 209,
"start_col": 0,
"start_line": 208
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> amt: Prims.int -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Prims.int",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Pslld dst amt =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_Mem128_lemma | val va_lemma_Mem128_lemma : va_b0:va_code -> va_s0:va_state -> h:heaplet_id -> base:operand64 ->
offset:int -> t:taint -> b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mem128_lemma ()) va_s0 /\ va_get_ok va_s0 /\ (let
heap_h = va_get_mem_heaplet h va_s0 in (OReg? base) /\ valid_src_addr heap_h b index /\
valid_layout_buffer b (va_get_mem_layout va_s0) heap_h false /\ valid_taint_buf128 b heap_h
((va_get_mem_layout va_s0).vl_taint) t /\ eval_operand base va_s0 + offset == buffer_addr b
heap_h + 16 `op_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 heap_h = va_get_mem_heaplet h va_s0 in valid_operand128 (va_opr_code_Mem128 h base offset
t) va_sM /\ load_mem128 (buffer_addr b heap_h + 16 `op_Multiply` index) (va_get_mem va_sM) ==
buffer_read b index heap_h) /\ va_state_eq va_sM (va_update_ok va_sM va_s0))) | val va_lemma_Mem128_lemma : va_b0:va_code -> va_s0:va_state -> h:heaplet_id -> base:operand64 ->
offset:int -> t:taint -> b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mem128_lemma ()) va_s0 /\ va_get_ok va_s0 /\ (let
heap_h = va_get_mem_heaplet h va_s0 in (OReg? base) /\ valid_src_addr heap_h b index /\
valid_layout_buffer b (va_get_mem_layout va_s0) heap_h false /\ valid_taint_buf128 b heap_h
((va_get_mem_layout va_s0).vl_taint) t /\ eval_operand base va_s0 + offset == buffer_addr b
heap_h + 16 `op_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 heap_h = va_get_mem_heaplet h va_s0 in valid_operand128 (va_opr_code_Mem128 h base offset
t) va_sM /\ load_mem128 (buffer_addr b heap_h + 16 `op_Multiply` index) (va_get_mem va_sM) ==
buffer_read b index heap_h) /\ va_state_eq va_sM (va_update_ok va_sM va_s0))) | let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 33,
"start_col": 0,
"start_line": 26
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
h: Vale.X64.Memory.heaplet_id ->
base: Vale.X64.Machine_s.operand64 ->
offset: Prims.int ->
t: Vale.Arch.HeapTypes_s.taint ->
b: Vale.X64.Memory.buffer128 ->
index: Prims.int
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Memory.heaplet_id",
"Vale.X64.Machine_s.operand64",
"Prims.int",
"Vale.Arch.HeapTypes_s.taint",
"Vale.X64.Memory.buffer128",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_lemma_empty_total",
"Prims.unit",
"Vale.X64.Decls.lemma_opr_Mem128",
"Vale.Arch.HeapImpl.vale_heap",
"Vale.X64.Decls.va_get_mem_heaplet",
"Prims.list",
"Vale.X64.Machine_s.precode",
"Vale.X64.Decls.ins",
"Vale.X64.Decls.ocmp",
"Vale.X64.Decls.va_get_block",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_Mem128_lemma"
] | [] | false | false | false | false | false | let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
| va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let va_old_s:va_state = va_s0 in
let va_b1:va_codes = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let va_sM, va_fM = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_Mem128_lemma | val va_wpProof_Mem128_lemma : h:heaplet_id -> base:operand64 -> offset:int -> t:taint ->
b:buffer128 -> index:int -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mem128_lemma h base offset t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mem128_lemma ()) ([]) va_s0 va_k
((va_sM, va_f0, va_g)))) | val va_wpProof_Mem128_lemma : h:heaplet_id -> base:operand64 -> offset:int -> t:taint ->
b:buffer128 -> index:int -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Mem128_lemma h base offset t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mem128_lemma ()) ([]) va_s0 va_k
((va_sM, va_f0, va_g)))) | let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 44,
"start_col": 0,
"start_line": 37
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h: Vale.X64.Memory.heaplet_id ->
base: Vale.X64.Machine_s.operand64 ->
offset: Prims.int ->
t: Vale.Arch.HeapTypes_s.taint ->
b: Vale.X64.Memory.buffer128 ->
index: Prims.int ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Memory.heaplet_id",
"Vale.X64.Machine_s.operand64",
"Prims.int",
"Vale.Arch.HeapTypes_s.taint",
"Vale.X64.Memory.buffer128",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Nil",
"Vale.X64.QuickCode.mod_t",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_Mem128_lemma",
"Vale.X64.InsVector.va_code_Mem128_lemma"
] | [] | false | false | false | false | false | let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Pxor | val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 87,
"end_line": 113,
"start_col": 0,
"start_line": 112
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr_annotate",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pxor",
"Vale.X64.Machine_Semantics_s.AnnotatePxor",
"Vale.X64.Instruction_s.InstrTypeRecord",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Pxor dst src =
| (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Paddd | val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 59,
"end_line": 51,
"start_col": 0,
"start_line": 50
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Paddd",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Paddd dst src =
| (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Psrld | val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool | val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool | let va_codegen_success_Psrld dst amt =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 238,
"start_col": 0,
"start_line": 237
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> amt: Prims.int -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Prims.int",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Psrld dst amt =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_Paddd | val va_lemma_Paddd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Paddd dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_xmm va_s0 dst) (va_eval_xmm
va_s0 src) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0))))) | val va_lemma_Paddd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Paddd dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_xmm va_s0 dst) (va_eval_xmm
va_s0 src) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0))))) | let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 64,
"start_col": 0,
"start_line": 58
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Paddd",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_Paddd"
] | [] | false | false | false | false | false | let va_lemma_Paddd va_b0 va_s0 dst src =
| va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let va_sM, va_fM = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_Paddd | val va_wpProof_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state -> va_k:(va_state
-> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Paddd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Paddd dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state -> va_k:(va_state
-> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Paddd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Paddd dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 75,
"start_col": 0,
"start_line": 68
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_Paddd",
"Vale.X64.InsVector.va_code_Paddd"
] | [] | false | false | false | false | false | let va_wpProof_Paddd dst src va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_VPaddd | val va_wpProof_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPaddd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPaddd dst src1 src2) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPaddd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPaddd dst src1 src2) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 106,
"start_col": 0,
"start_line": 99
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_VPaddd",
"Vale.X64.InsVector.va_code_VPaddd"
] | [] | false | false | false | false | false | let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
| let va_sM, va_f0 = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_Pxor | val va_wpProof_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state -> va_k:(va_state
-> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Pxor dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pxor dst src) ([va_mod_xmm dst]) va_s0
va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state -> va_k:(va_state
-> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Pxor dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pxor dst src) ([va_mod_xmm dst]) va_s0
va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 137,
"start_col": 0,
"start_line": 131
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_Pxor",
"Vale.X64.InsVector.va_code_Pxor"
] | [] | false | false | false | false | false | let va_wpProof_Pxor dst src va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Pand | val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code | val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code | let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 145,
"start_col": 0,
"start_line": 144
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_opr128
-> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr128",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pand",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Pand dst src =
| (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_Pxor | val va_lemma_Pxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pxor dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_xmm va_s0 dst) (va_eval_xmm va_s0
src) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | val va_lemma_Pxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pxor dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_xmm va_s0 dst) (va_eval_xmm va_s0
src) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 127,
"start_col": 0,
"start_line": 120
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr_annotate",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pxor",
"Vale.X64.Machine_Semantics_s.AnnotatePxor",
"Vale.X64.Instruction_s.InstrTypeRecord",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_Pxor"
] | [] | false | false | false | false | false | let va_lemma_Pxor va_b0 va_s0 dst src =
| va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
va_s0;
let va_sM, va_fM =
va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
va_s0
in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_VPxor | val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code | val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code | let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2)) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 95,
"end_line": 174,
"start_col": 0,
"start_line": 173
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_opr128
-> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr128",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr_annotate",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_VPxor",
"Vale.X64.Machine_Semantics_s.AnnotateVPxor",
"Vale.X64.Instruction_s.InstrTypeRecord",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_VPxor dst src1 src2 =
| (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2)) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_Pand | val va_wpProof_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Pand dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pand dst src) ([va_mod_xmm dst]) va_s0
va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Pand dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pand dst src) ([va_mod_xmm dst]) va_s0
va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 167,
"start_col": 0,
"start_line": 161
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_opr128 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr128",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_Pand",
"Vale.X64.InsVector.va_code_Pand"
] | [] | false | false | false | false | false | let va_wpProof_Pand dst src va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Psrldq | val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool | val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool | let va_codegen_success_Psrldq dst amt =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 269,
"start_col": 0,
"start_line": 268
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> amt: Prims.int -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Prims.int",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Psrldq dst amt =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Palignr4 | val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | let va_codegen_success_Palignr4 dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 331,
"start_col": 0,
"start_line": 330
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Palignr4 dst src =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_VPxor | val va_wpProof_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPxor dst src1 src2) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPxor dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPxor dst src1 src2) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 198,
"start_col": 0,
"start_line": 192
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_opr128 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr128",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_VPxor",
"Vale.X64.InsVector.va_code_VPxor"
] | [] | false | false | false | false | false | let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
| let va_sM, va_f0 = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Pslld | val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code | val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code | let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 205,
"start_col": 0,
"start_line": 204
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> amt: Prims.int -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Prims.int",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pslld",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Pslld dst amt =
| (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Palignr8 | val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | let va_codegen_success_Palignr8 dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 362,
"start_col": 0,
"start_line": 361
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Palignr8 dst src =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_VPalignr8 | val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool | val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool | let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 393,
"start_col": 0,
"start_line": 392
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_VPalignr8 dst src1 src2 =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_VPaddd | val va_lemma_VPaddd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src1:va_operand_xmm
-> src2:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPaddd dst src1 src2) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src1 va_s0 /\ va_is_src_xmm src2 va_s0 /\ va_get_ok va_s0 /\ avx_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_xmm va_s0 src1) (va_eval_xmm
va_s0 src2) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0))))) | val va_lemma_VPaddd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src1:va_operand_xmm
-> src2:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPaddd dst src1 src2) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src1 va_s0 /\ va_is_src_xmm src2 va_s0 /\ va_get_ok va_s0 /\ avx_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Arch.Types.add_wrap_quad32 (va_eval_xmm va_s0 src1) (va_eval_xmm
va_s0 src2) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0))))) | let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 95,
"start_col": 0,
"start_line": 89
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_VPaddd",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_VPaddd"
] | [] | false | false | false | false | false | let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
| va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let va_sM, va_fM =
va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0
in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Psrld | val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code | val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code | let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 234,
"start_col": 0,
"start_line": 233
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> amt: Prims.int -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Prims.int",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Psrld",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Psrld dst amt =
| (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Psrldq | val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code | val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code | let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 53,
"end_line": 264,
"start_col": 0,
"start_line": 263
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> amt: Prims.int -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Prims.int",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Psrldq",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Psrldq dst amt =
| (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Shufpd | val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool | val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool | let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 424,
"start_col": 0,
"start_line": 423
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
permutation: Vale.X64.Memory.nat8
-> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Shufpd dst src permutation =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_Psrld | val va_wpProof_Psrld : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit ->
Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrld dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrld dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_Psrld : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit ->
Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrld dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrld dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 256,
"start_col": 0,
"start_line": 250
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
amt: Prims.int ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Prims.int",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_Psrld",
"Vale.X64.InsVector.va_code_Psrld"
] | [] | false | false | false | false | false | let va_wpProof_Psrld dst amt va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_Pand | val va_lemma_Pand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pand dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm 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_xmm va_s0 dst) (va_eval_opr128
va_s0 src) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | val va_lemma_Pand : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pand dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm 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_xmm va_s0 dst) (va_eval_opr128
va_s0 src) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 157,
"start_col": 0,
"start_line": 152
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_opr128
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr128",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pand",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_Pand"
] | [] | false | false | false | false | false | let va_lemma_Pand va_b0 va_s0 dst src =
| va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let va_sM, va_fM = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_VShufpd | val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool | val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool | let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 456,
"start_col": 0,
"start_line": 455
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm ->
permutation: Vale.X64.Memory.nat8
-> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_VShufpd dst src1 src2 permutation =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_Pslld | val va_lemma_Pslld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pslld dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 32)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Types_s.nat32 (fun
(i:nat32) -> Vale.Arch.Types.ishl32 i amt) (va_eval_xmm va_s0 dst) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | val va_lemma_Pslld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pslld dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 32)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Types_s.nat32 (fun
(i:nat32) -> Vale.Arch.Types.ishl32 i amt) (va_eval_xmm va_s0 dst) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 217,
"start_col": 0,
"start_line": 212
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
amt: Prims.int
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Prims.int",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pslld",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_Pslld"
] | [] | false | false | false | false | false | let va_lemma_Pslld va_b0 va_s0 dst amt =
| va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let va_sM, va_fM = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Palignr4 | val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 327,
"start_col": 0,
"start_line": 326
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4 | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Palignr",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Palignr4 dst src =
| (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_quick_Psrldq | val va_quick_Psrldq (dst: va_operand_xmm) (amt: int) : (va_quickCode unit (va_code_Psrldq dst amt)) | val va_quick_Psrldq (dst: va_operand_xmm) (amt: int) : (va_quickCode unit (va_code_Psrldq dst amt)) | let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt)) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 321,
"start_col": 0,
"start_line": 319
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> amt: Prims.int
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_Psrldq dst amt) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Prims.int",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_Psrldq",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_Psrldq",
"Vale.X64.InsVector.va_wpProof_Psrldq",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Psrldq (dst: va_operand_xmm) (amt: int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
| (va_QProc (va_code_Psrldq dst amt)
([va_mod_xmm dst])
(va_wp_Psrldq dst amt)
(va_wpProof_Psrldq dst amt)) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wp_Psrldq | val va_wp_Psrldq
(dst: va_operand_xmm)
(amt: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Psrldq
(dst: va_operand_xmm)
(amt: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 300,
"start_col": 0,
"start_line": 292
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
amt: Prims.int ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Prims.int",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Types_s.quad32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Types_s.le_bytes_to_quad32",
"FStar.Seq.Base.append",
"Vale.X64.Memory.nat8",
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"FStar.Seq.Base.slice",
"Vale.Def.Types_s.nat8",
"FStar.Seq.Base.length",
"FStar.Seq.Base.create",
"Vale.Def.Types_s.le_quad32_to_bytes",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Psrldq
(dst: va_operand_xmm)
(amt: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\
(forall (va_x_dst: va_value_xmm).
let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in
va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in
let zero_pad = FStar.Seq.Base.create #nat8 amt 0 in
let remaining_bytes =
FStar.Seq.Base.slice #Vale.Def.Types_s.nat8
src_bytes
amt
(FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in
va_eval_xmm va_sM dst ==
Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8 zero_pad remaining_bytes)) ==>
va_k va_sM (()))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_Pslld | val va_wpProof_Pslld : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit ->
Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Pslld dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pslld dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_Pslld : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit ->
Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Pslld dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pslld dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 227,
"start_col": 0,
"start_line": 221
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
amt: Prims.int ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Prims.int",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_Pslld",
"Vale.X64.InsVector.va_code_Pslld"
] | [] | false | false | false | false | false | let va_wpProof_Pslld dst amt va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Pshufb | val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | let va_codegen_success_Pshufb dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 489,
"start_col": 0,
"start_line": 488
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Pshufb dst src =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_VPxor | val va_lemma_VPxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src1:va_operand_xmm
-> src2:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPxor dst src1 src2) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok va_s0 /\ avx_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_xmm va_s0 src1) (va_eval_opr128
va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | val va_lemma_VPxor : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src1:va_operand_xmm
-> src2:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPxor dst src1 src2) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok va_s0 /\ avx_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.quad32_xor (va_eval_xmm va_s0 src1) (va_eval_opr128
va_s0 src2) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 188,
"start_col": 0,
"start_line": 181
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_opr128
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr128",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr_annotate",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_VPxor",
"Vale.X64.Machine_Semantics_s.AnnotateVPxor",
"Vale.X64.Instruction_s.InstrTypeRecord",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_VPxor"
] | [] | false | false | false | false | false | let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
| va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor)
(S.AnnotateVPxor ())
(OReg dst)
(OReg src1)
src2))
va_s0;
let va_sM, va_fM =
va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor)
(S.AnnotateVPxor ())
(OReg dst)
(OReg src1)
src2))
va_s0
in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_Palignr4 | val va_wpProof_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Palignr4 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Palignr4 dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Palignr4 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Palignr4 dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 351,
"start_col": 0,
"start_line": 344
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_Palignr4",
"Vale.X64.InsVector.va_code_Palignr4"
] | [] | false | false | false | false | false | let va_wpProof_Palignr4 dst src va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_VPshufb | val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool | val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool | let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 520,
"start_col": 0,
"start_line": 519
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_VPshufb dst src1 src2 =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_Psrldq | val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 316,
"start_col": 0,
"start_line": 310
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
amt: Prims.int ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Prims.int",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_Psrldq",
"Vale.X64.InsVector.va_code_Psrldq"
] | [] | false | false | false | false | false | let va_wpProof_Psrldq dst amt va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_VPalignr8 | val va_wpProof_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPalignr8 dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPalignr8 dst src1 src2)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPalignr8 dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPalignr8 dst src1 src2)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 413,
"start_col": 0,
"start_line": 406
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_VPalignr8",
"Vale.X64.InsVector.va_code_VPalignr8"
] | [] | false | false | false | false | false | let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
| let va_sM, va_f0 = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_Psrld | val va_lemma_Psrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrld dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 32)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Types_s.nat32 (fun
(i:nat32) -> Vale.Arch.Types.ishr32 i amt) (va_eval_xmm va_s0 dst) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | val va_lemma_Psrld : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrld dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 32)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words.Four_s.four_map #nat32 #Vale.Def.Types_s.nat32 (fun
(i:nat32) -> Vale.Arch.Types.ishr32 i amt) (va_eval_xmm va_s0 dst) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 246,
"start_col": 0,
"start_line": 241
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
amt: Prims.int
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Prims.int",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Psrld",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_Psrld"
] | [] | false | false | false | false | false | let va_lemma_Psrld va_b0 va_s0 dst amt =
| va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let va_sM, va_fM = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_Psrldq | val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0)))) | val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0)))) | let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 289,
"start_col": 0,
"start_line": 284
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
amt: Prims.int
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Prims.int",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Psrldq",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_Psrldq"
] | [] | false | false | false | false | false | let va_lemma_Psrldq va_b0 va_s0 dst amt =
| va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let va_sM, va_fM = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Palignr8 | val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 358,
"start_col": 0,
"start_line": 357
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8 | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Palignr",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Palignr8 dst src =
| (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_Palignr4 | val va_lemma_Palignr4 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Palignr4 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))) | val va_lemma_Palignr4 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Palignr4 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))) | let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 340,
"start_col": 0,
"start_line": 334
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Palignr",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_Palignr4"
] | [] | false | false | false | false | false | let va_lemma_Palignr4 va_b0 va_s0 dst src =
| va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let va_sM, va_fM =
va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_VPalignr8 | val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code | val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code | let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 77,
"end_line": 389,
"start_col": 0,
"start_line": 388
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8 | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_VPalignr",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_VPalignr8 dst src1 src2 =
| (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Shufpd | val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code | val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code | let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 72,
"end_line": 420,
"start_col": 0,
"start_line": 419
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
permutation: Vale.X64.Memory.nat8
-> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Shufpd",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Shufpd dst src permutation =
| (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_VPalignr8 | val va_lemma_VPalignr8 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPalignr8 dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_xmm src2 va_s0 /\ va_get_ok va_s0 /\
avx_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src1)) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))) | val va_lemma_VPalignr8 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPalignr8 dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_xmm src2 va_s0 /\ va_get_ok va_s0 /\
avx_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src1)) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))) | let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 402,
"start_col": 0,
"start_line": 396
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_VPalignr",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_VPalignr8"
] | [] | false | false | false | false | false | let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
| va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let va_sM, va_fM =
va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0
in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_Palignr8 | val va_lemma_Palignr8 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Palignr8 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))) | val va_lemma_Palignr8 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Palignr8 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))) | let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 371,
"start_col": 0,
"start_line": 365
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Palignr",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_Palignr8"
] | [] | false | false | false | false | false | let va_lemma_Palignr8 va_b0 va_s0 dst src =
| va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let va_sM, va_fM =
va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_Palignr8 | val va_wpProof_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Palignr8 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Palignr8 dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Palignr8 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Palignr8 dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 382,
"start_col": 0,
"start_line": 375
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_Palignr8",
"Vale.X64.InsVector.va_code_Palignr8"
] | [] | false | false | false | false | false | let va_wpProof_Palignr8 dst src va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Pshufb | val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 60,
"end_line": 485,
"start_col": 0,
"start_line": 484
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pshufb",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Pshufb dst src =
| (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_PshufbStable | val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | let va_codegen_success_PshufbStable dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 551,
"start_col": 0,
"start_line": 550
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_PshufbStable dst src =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_PshufbDup | val va_codegen_success_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | val va_codegen_success_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | let va_codegen_success_PshufbDup dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 582,
"start_col": 0,
"start_line": 581
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_PshufbDup dst src =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_VShufpd | val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code | val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code | let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 86,
"end_line": 452,
"start_col": 0,
"start_line": 451
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm ->
permutation: Vale.X64.Memory.nat8
-> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_VShufpd",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_VShufpd dst src1 src2 permutation =
| (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_VShufpd | val va_wpProof_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VShufpd dst src1 src2 permutation va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VShufpd dst src1 src2 permutation)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VShufpd dst src1 src2 permutation va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VShufpd dst src1 src2 permutation)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 478,
"start_col": 0,
"start_line": 470
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm ->
permutation: Vale.X64.Memory.nat8 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_VShufpd",
"Vale.X64.InsVector.va_code_VShufpd"
] | [] | false | false | false | false | false | let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
| let va_sM, va_f0 =
va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1 src2 permutation
in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_Shufpd | val va_lemma_Shufpd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> permutation:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Shufpd dst src permutation) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if (permutation = 0
|| permutation = 2) then Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)
else Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) (if (permutation = 0
|| permutation = 2) then Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)
else Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) (if (permutation = 0
|| permutation = 1) then Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)
else Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src)) (if (permutation = 0
|| permutation = 1) then Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src)
else Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src)) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))) | val va_lemma_Shufpd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> permutation:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Shufpd dst src permutation) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if (permutation = 0
|| permutation = 2) then Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)
else Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) (if (permutation = 0
|| permutation = 2) then Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)
else Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) (if (permutation = 0
|| permutation = 1) then Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)
else Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src)) (if (permutation = 0
|| permutation = 1) then Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src)
else Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src)) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))) | let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 433,
"start_col": 0,
"start_line": 427
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
permutation: Vale.X64.Memory.nat8
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Shufpd",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_Shufpd"
] | [] | false | false | false | false | false | let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
| va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let va_sM, va_fM =
va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_Shufpd | val va_wpProof_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Shufpd dst src permutation va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Shufpd dst src permutation)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Shufpd dst src permutation va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Shufpd dst src permutation)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 445,
"start_col": 0,
"start_line": 437
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
permutation: Vale.X64.Memory.nat8 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_Shufpd",
"Vale.X64.InsVector.va_code_Shufpd"
] | [] | false | false | false | false | false | let va_wpProof_Shufpd dst src permutation va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Pshufb64 | val va_codegen_success_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | val va_codegen_success_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | let va_codegen_success_Pshufb64 dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 613,
"start_col": 0,
"start_line": 612
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Pshufb64 dst src =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_Pshufb | val va_wpProof_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Pshufb dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pshufb dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Pshufb dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pshufb dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 509,
"start_col": 0,
"start_line": 502
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_Pshufb",
"Vale.X64.InsVector.va_code_Pshufb"
] | [] | false | false | false | false | false | let va_wpProof_Pshufb dst src va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_Pshufb | val va_lemma_Pshufb : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pshufb dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_xmm va_s0 src ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 202182159 134810123 67438087 66051))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.reverse_bytes_quad32 (va_eval_xmm va_s0 dst) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))) | val va_lemma_Pshufb : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pshufb dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_xmm va_s0 src ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 202182159 134810123 67438087 66051))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.reverse_bytes_quad32 (va_eval_xmm va_s0 dst) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))) | let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 498,
"start_col": 0,
"start_line": 492
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pshufb",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_Pshufb"
] | [] | false | false | false | false | false | let va_lemma_Pshufb va_b0 va_s0 dst src =
| va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let va_sM, va_fM = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Pshufd | val va_codegen_success_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool | val va_codegen_success_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool | let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 644,
"start_col": 0,
"start_line": 643
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
permutation: Vale.X64.Memory.nat8
-> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Pshufd dst src permutation =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_VShufpd | val va_lemma_VShufpd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src1:va_operand_xmm
-> src2:va_operand_xmm -> permutation:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VShufpd dst src1 src2 permutation) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_xmm src2 va_s0 /\ va_get_ok
va_s0 /\ avx_enabled /\ permutation < 4))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if (permutation = 0
|| permutation = 2) then Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)
else Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1)) (if (permutation = 0
|| permutation = 2) then Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src1)
else Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1)) (if (permutation = 0
|| permutation = 1) then Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src2)
else Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src2)) (if (permutation = 0
|| permutation = 1) then Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)
else Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2)) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))) | val va_lemma_VShufpd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src1:va_operand_xmm
-> src2:va_operand_xmm -> permutation:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VShufpd dst src1 src2 permutation) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_xmm src2 va_s0 /\ va_get_ok
va_s0 /\ avx_enabled /\ permutation < 4))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (if (permutation = 0
|| permutation = 2) then Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)
else Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1)) (if (permutation = 0
|| permutation = 2) then Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src1)
else Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1)) (if (permutation = 0
|| permutation = 1) then Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src2)
else Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src2)) (if (permutation = 0
|| permutation = 1) then Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)
else Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2)) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))) | let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 466,
"start_col": 0,
"start_line": 459
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm ->
permutation: Vale.X64.Memory.nat8
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_VShufpd",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_VShufpd"
] | [] | false | false | false | false | false | let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
| va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let va_sM, va_fM =
va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0
in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Pcmpeqd | val va_codegen_success_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | val va_codegen_success_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | let va_codegen_success_Pcmpeqd dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 675,
"start_col": 0,
"start_line": 674
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufd (va_code_Pshufd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pcmpeqd
[@ "opaque_to_smt"]
let va_code_Pcmpeqd dst src =
(mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Pcmpeqd dst src =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_PshufbStable | val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 60,
"end_line": 547,
"start_col": 0,
"start_line": 546
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pshufb",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_PshufbStable dst src =
| (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_VPshufb | val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code | val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code | let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 74,
"end_line": 516,
"start_col": 0,
"start_line": 515
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_VPshufb",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_VPshufb dst src1 src2 =
| (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Pextrq | val va_codegen_success_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot
va_pbool | val va_codegen_success_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot
va_pbool | let va_codegen_success_Pextrq dst src index =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 705,
"start_col": 0,
"start_line": 704
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufd (va_code_Pshufd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pcmpeqd
[@ "opaque_to_smt"]
let va_code_Pcmpeqd dst src =
(mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pcmpeqd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pcmpeqd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pcmpeqd) (va_code_Pcmpeqd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pcmpeqd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pcmpeqd (va_code_Pcmpeqd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pextrq
[@ "opaque_to_smt"]
let va_code_Pextrq dst src index =
(mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_dst_opr64 ->
src: Vale.X64.Decls.va_operand_xmm ->
index: Vale.X64.Memory.nat8
-> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Pextrq dst src index =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_VPshufb | val va_wpProof_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPshufb dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPshufb dst src1 src2) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPshufb dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPshufb dst src1 src2) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 540,
"start_col": 0,
"start_line": 533
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_VPshufb",
"Vale.X64.InsVector.va_code_VPshufb"
] | [] | false | false | false | false | false | let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
| let va_sM, va_f0 = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_VPshufb | val va_lemma_VPshufb : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src1:va_operand_xmm
-> src2:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPshufb dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_xmm src2 va_s0 /\ va_get_ok va_s0 /\ avx_enabled
/\ va_eval_xmm va_s0 src2 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 202182159
134810123 67438087 66051))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.reverse_bytes_quad32 (va_eval_xmm va_s0 src1) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))) | val va_lemma_VPshufb : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src1:va_operand_xmm
-> src2:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPshufb dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_xmm src2 va_s0 /\ va_get_ok va_s0 /\ avx_enabled
/\ va_eval_xmm va_s0 src2 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 202182159
134810123 67438087 66051))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.reverse_bytes_quad32 (va_eval_xmm va_s0 src1) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))) | let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 529,
"start_col": 0,
"start_line": 523
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_VPshufb",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_VPshufb"
] | [] | false | false | false | false | false | let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
| va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let va_sM, va_fM =
va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0
in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_PshufbDup | val va_code_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | val va_code_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 60,
"end_line": 578,
"start_col": 0,
"start_line": 577
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pshufb",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_PshufbDup dst src =
| (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Pinsrd | val va_codegen_success_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool | val va_codegen_success_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool | let va_codegen_success_Pinsrd dst src index =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 737,
"start_col": 0,
"start_line": 736
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufd (va_code_Pshufd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pcmpeqd
[@ "opaque_to_smt"]
let va_code_Pcmpeqd dst src =
(mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pcmpeqd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pcmpeqd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pcmpeqd) (va_code_Pcmpeqd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pcmpeqd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pcmpeqd (va_code_Pcmpeqd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pextrq
[@ "opaque_to_smt"]
let va_code_Pextrq dst src index =
(mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pextrq dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pextrq va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pextrq) (va_code_Pextrq dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0
in
Vale.Arch.Types.lo64_reveal ();
Vale.Arch.Types.hi64_reveal ();
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pextrq dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pextrq (va_code_Pextrq dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pinsrd
[@ "opaque_to_smt"]
let va_code_Pinsrd dst src index =
(mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src)) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_opr64 ->
index: Vale.X64.Memory.nat8
-> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Pinsrd dst src index =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_PshufbStable | val va_wpProof_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PshufbStable dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PshufbStable dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PshufbStable dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PshufbStable dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 571,
"start_col": 0,
"start_line": 564
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_PshufbStable",
"Vale.X64.InsVector.va_code_PshufbStable"
] | [] | false | false | false | false | false | let va_wpProof_PshufbStable dst src va_s0 va_k =
| let va_sM, va_f0 = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Pshufb64 | val va_code_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | val va_code_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 60,
"end_line": 609,
"start_col": 0,
"start_line": 608
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64 | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pshufb",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Pshufb64 dst src =
| (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_PshufbDup | val va_lemma_PshufbDup : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PshufbDup dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_xmm va_s0 src ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 202182159 134810123 202182159 134810123))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2
(va_eval_xmm va_s0 dst))) (Vale.Def.Types_s.reverse_bytes_nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)))
(Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 dst))) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0))))) | val va_lemma_PshufbDup : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PshufbDup dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_xmm va_s0 src ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 202182159 134810123 202182159 134810123))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2
(va_eval_xmm va_s0 dst))) (Vale.Def.Types_s.reverse_bytes_nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)))
(Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 dst))) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0))))) | let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 591,
"start_col": 0,
"start_line": 585
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pshufb",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_PshufbDup"
] | [] | false | false | false | false | false | let va_lemma_PshufbDup va_b0 va_s0 dst src =
| va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let va_sM, va_fM = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Pinsrq | val va_codegen_success_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool | val va_codegen_success_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool | let va_codegen_success_Pinsrq dst src index =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 811,
"start_col": 0,
"start_line": 810
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufd (va_code_Pshufd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pcmpeqd
[@ "opaque_to_smt"]
let va_code_Pcmpeqd dst src =
(mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pcmpeqd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pcmpeqd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pcmpeqd) (va_code_Pcmpeqd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pcmpeqd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pcmpeqd (va_code_Pcmpeqd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pextrq
[@ "opaque_to_smt"]
let va_code_Pextrq dst src index =
(mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pextrq dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pextrq va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pextrq) (va_code_Pextrq dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0
in
Vale.Arch.Types.lo64_reveal ();
Vale.Arch.Types.hi64_reveal ();
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pextrq dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pextrq (va_code_Pextrq dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pinsrd
[@ "opaque_to_smt"]
let va_code_Pinsrd dst src index =
(mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pinsrd dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pinsrd va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pinsrd) (va_code_Pinsrd dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src)) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pinsrd dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pinsrd (va_code_Pinsrd dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PinsrdImm
[@ "opaque_to_smt"]
let va_code_PinsrdImm dst immediate index tmp =
(va_Block (va_CCons (va_code_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_CCons (va_code_Pinsrd dst (va_coerce_reg_opr64_to_opr64 tmp) index) (va_CNil
()))))
[@ "opaque_to_smt"]
let va_codegen_success_PinsrdImm dst immediate index tmp =
(va_pbool_and (va_codegen_success_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_pbool_and (va_codegen_success_Pinsrd dst (va_coerce_reg_opr64_to_opr64 tmp)
index) (va_ttrue ())))
[@"opaque_to_smt"]
let va_lemma_PinsrdImm va_b0 va_s0 dst immediate index tmp =
va_reveal_opaque (`%va_code_PinsrdImm) (va_code_PinsrdImm dst immediate index tmp);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s2, va_fc2) = va_lemma_Mov64 (va_hd va_b1) va_s0 (va_coerce_reg_opr64_to_dst_opr64 tmp)
(va_const_opr64 immediate) in
let va_b2 = va_tl va_b1 in
let (va_s3, va_fc3) = va_lemma_Pinsrd (va_hd va_b2) va_s2 dst (va_coerce_reg_opr64_to_opr64 tmp)
index in
let va_b3 = va_tl va_b2 in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_f2 = va_lemma_merge_total va_b2 va_s2 va_fc3 va_s3 va_f3 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc2 va_s2 va_f2 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PinsrdImm dst immediate index tmp va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PinsrdImm (va_code_PinsrdImm dst immediate index tmp) va_s0 dst
immediate index tmp in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_reg_opr64 tmp va_sM
(va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pinsrq
[@ "opaque_to_smt"]
let va_code_Pinsrq dst src index =
(mk_ins (make_instr (I.ins_Pinsrq index) (OReg dst) src)) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_opr64 ->
index: Vale.X64.Memory.nat8
-> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Pinsrq dst src index =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Pshufd | val va_code_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code | val va_code_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code | let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 72,
"end_line": 640,
"start_col": 0,
"start_line": 639
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
permutation: Vale.X64.Memory.nat8
-> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pshufd",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Pshufd dst src permutation =
| (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_PshufbStable | val va_lemma_PshufbStable : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PshufbStable dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_xmm va_s0 src ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 66051 67438087 134810123 202182159))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm
va_s0 dst))) (Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst))) (Vale.Def.Types_s.reverse_bytes_nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)))
(Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) /\ va_eval_xmm va_sM dst == Vale.Arch.Types.reverse_bytes_nat32_quad32
(va_eval_xmm va_s0 dst) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0))))) | val va_lemma_PshufbStable : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PshufbStable dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_xmm va_s0 src ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 66051 67438087 134810123 202182159))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm
va_s0 dst))) (Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst))) (Vale.Def.Types_s.reverse_bytes_nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)))
(Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) /\ va_eval_xmm va_sM dst == Vale.Arch.Types.reverse_bytes_nat32_quad32
(va_eval_xmm va_s0 dst) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0))))) | let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 560,
"start_col": 0,
"start_line": 554
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pshufb",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_PshufbStable"
] | [] | false | false | false | false | false | let va_lemma_PshufbStable va_b0 va_s0 dst src =
| va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let va_sM, va_fM = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_Pshufb64 | val va_wpProof_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Pshufb64 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pshufb64 dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Pshufb64 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pshufb64 dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 633,
"start_col": 0,
"start_line": 626
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_Pshufb64",
"Vale.X64.InsVector.va_code_Pshufb64"
] | [] | false | false | false | false | false | let va_wpProof_Pshufb64 dst src va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_PshufbDup | val va_wpProof_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PshufbDup dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PshufbDup dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PshufbDup dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PshufbDup dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 602,
"start_col": 0,
"start_line": 595
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_PshufbDup",
"Vale.X64.InsVector.va_code_PshufbDup"
] | [] | false | false | false | false | false | let va_wpProof_PshufbDup dst src va_s0 va_k =
| let va_sM, va_f0 = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_Pshufd | val va_wpProof_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Pshufd dst src permutation va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pshufd dst src permutation)
([va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Pshufd dst src permutation va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pshufd dst src permutation)
([va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_Pshufd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufd (va_code_Pshufd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 664,
"start_col": 0,
"start_line": 657
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
permutation: Vale.X64.Memory.nat8 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_xmm",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_Pshufd",
"Vale.X64.InsVector.va_code_Pshufd"
] | [] | false | false | false | false | false | let va_wpProof_Pshufd dst src permutation va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Pshufd (va_code_Pshufd dst src permutation) va_s0 dst src permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_Pshufb64 | val va_lemma_Pshufb64 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pshufb64 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_xmm va_s0 src ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 67438087 66051 202182159 134810123))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm
va_s0 dst))) (Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 dst))) (Vale.Def.Types_s.reverse_bytes_nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)))
(Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 dst))) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0))))) | val va_lemma_Pshufb64 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pshufb64 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_xmm va_s0 src ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 67438087 66051 202182159 134810123))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm
va_s0 dst))) (Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 dst))) (Vale.Def.Types_s.reverse_bytes_nat32
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)))
(Vale.Def.Types_s.reverse_bytes_nat32 (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 dst))) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0))))) | let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 622,
"start_col": 0,
"start_line": 616
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pshufb",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_Pshufb64"
] | [] | false | false | false | false | false | let va_lemma_Pshufb64 va_b0 va_s0 dst src =
| va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let va_sM, va_fM = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_PinsrqImm | val va_codegen_success_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool | val va_codegen_success_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool | let va_codegen_success_PinsrqImm dst immediate index tmp =
(va_pbool_and (va_codegen_success_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_pbool_and (va_codegen_success_Pinsrq dst (va_coerce_reg_opr64_to_opr64 tmp)
index) (va_ttrue ()))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 848,
"start_col": 0,
"start_line": 845
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufd (va_code_Pshufd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pcmpeqd
[@ "opaque_to_smt"]
let va_code_Pcmpeqd dst src =
(mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pcmpeqd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pcmpeqd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pcmpeqd) (va_code_Pcmpeqd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pcmpeqd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pcmpeqd (va_code_Pcmpeqd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pextrq
[@ "opaque_to_smt"]
let va_code_Pextrq dst src index =
(mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pextrq dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pextrq va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pextrq) (va_code_Pextrq dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0
in
Vale.Arch.Types.lo64_reveal ();
Vale.Arch.Types.hi64_reveal ();
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pextrq dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pextrq (va_code_Pextrq dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pinsrd
[@ "opaque_to_smt"]
let va_code_Pinsrd dst src index =
(mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pinsrd dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pinsrd va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pinsrd) (va_code_Pinsrd dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src)) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pinsrd dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pinsrd (va_code_Pinsrd dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PinsrdImm
[@ "opaque_to_smt"]
let va_code_PinsrdImm dst immediate index tmp =
(va_Block (va_CCons (va_code_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_CCons (va_code_Pinsrd dst (va_coerce_reg_opr64_to_opr64 tmp) index) (va_CNil
()))))
[@ "opaque_to_smt"]
let va_codegen_success_PinsrdImm dst immediate index tmp =
(va_pbool_and (va_codegen_success_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_pbool_and (va_codegen_success_Pinsrd dst (va_coerce_reg_opr64_to_opr64 tmp)
index) (va_ttrue ())))
[@"opaque_to_smt"]
let va_lemma_PinsrdImm va_b0 va_s0 dst immediate index tmp =
va_reveal_opaque (`%va_code_PinsrdImm) (va_code_PinsrdImm dst immediate index tmp);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s2, va_fc2) = va_lemma_Mov64 (va_hd va_b1) va_s0 (va_coerce_reg_opr64_to_dst_opr64 tmp)
(va_const_opr64 immediate) in
let va_b2 = va_tl va_b1 in
let (va_s3, va_fc3) = va_lemma_Pinsrd (va_hd va_b2) va_s2 dst (va_coerce_reg_opr64_to_opr64 tmp)
index in
let va_b3 = va_tl va_b2 in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_f2 = va_lemma_merge_total va_b2 va_s2 va_fc3 va_s3 va_f3 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc2 va_s2 va_f2 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PinsrdImm dst immediate index tmp va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PinsrdImm (va_code_PinsrdImm dst immediate index tmp) va_s0 dst
immediate index tmp in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_reg_opr64 tmp va_sM
(va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pinsrq
[@ "opaque_to_smt"]
let va_code_Pinsrq dst src index =
(mk_ins (make_instr (I.ins_Pinsrq index) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pinsrq dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pinsrq va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pinsrq) (va_code_Pinsrq dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pinsrq index) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pinsrq index) (OReg dst) src)) va_s0
in
Vale.Def.Types_s.insert_nat64_reveal ();
assert (va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64_def (va_eval_xmm va_old_s dst)
(va_eval_opr64 va_sM src) index);
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pinsrq dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pinsrq (va_code_Pinsrq dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PinsrqImm
[@ "opaque_to_smt"]
let va_code_PinsrqImm dst immediate index tmp =
(va_Block (va_CCons (va_code_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_CCons (va_code_Pinsrq dst (va_coerce_reg_opr64_to_opr64 tmp) index) (va_CNil
())))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
immediate: Vale.X64.Memory.nat64 ->
index: Vale.X64.Memory.nat8 ->
tmp: Vale.X64.Decls.va_operand_reg_opr64
-> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_operand_reg_opr64",
"Vale.X64.Decls.va_pbool_and",
"Vale.X64.InsBasic.va_codegen_success_Mov64",
"Vale.X64.Decls.va_coerce_reg_opr64_to_dst_opr64",
"Vale.X64.Decls.va_const_opr64",
"Vale.X64.InsVector.va_codegen_success_Pinsrq",
"Vale.X64.Decls.va_coerce_reg_opr64_to_opr64",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_PinsrqImm dst immediate index tmp =
| (va_pbool_and (va_codegen_success_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp)
(va_const_opr64 immediate))
(va_pbool_and (va_codegen_success_Pinsrq dst (va_coerce_reg_opr64_to_opr64 tmp) index)
(va_ttrue ()))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_PinsrqImm | val va_code_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code | val va_code_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code | let va_code_PinsrqImm dst immediate index tmp =
(va_Block (va_CCons (va_code_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_CCons (va_code_Pinsrq dst (va_coerce_reg_opr64_to_opr64 tmp) index) (va_CNil
())))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 842,
"start_col": 0,
"start_line": 839
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufd (va_code_Pshufd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pcmpeqd
[@ "opaque_to_smt"]
let va_code_Pcmpeqd dst src =
(mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pcmpeqd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pcmpeqd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pcmpeqd) (va_code_Pcmpeqd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pcmpeqd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pcmpeqd (va_code_Pcmpeqd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pextrq
[@ "opaque_to_smt"]
let va_code_Pextrq dst src index =
(mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pextrq dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pextrq va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pextrq) (va_code_Pextrq dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0
in
Vale.Arch.Types.lo64_reveal ();
Vale.Arch.Types.hi64_reveal ();
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pextrq dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pextrq (va_code_Pextrq dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pinsrd
[@ "opaque_to_smt"]
let va_code_Pinsrd dst src index =
(mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pinsrd dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pinsrd va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pinsrd) (va_code_Pinsrd dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src)) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pinsrd dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pinsrd (va_code_Pinsrd dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PinsrdImm
[@ "opaque_to_smt"]
let va_code_PinsrdImm dst immediate index tmp =
(va_Block (va_CCons (va_code_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_CCons (va_code_Pinsrd dst (va_coerce_reg_opr64_to_opr64 tmp) index) (va_CNil
()))))
[@ "opaque_to_smt"]
let va_codegen_success_PinsrdImm dst immediate index tmp =
(va_pbool_and (va_codegen_success_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_pbool_and (va_codegen_success_Pinsrd dst (va_coerce_reg_opr64_to_opr64 tmp)
index) (va_ttrue ())))
[@"opaque_to_smt"]
let va_lemma_PinsrdImm va_b0 va_s0 dst immediate index tmp =
va_reveal_opaque (`%va_code_PinsrdImm) (va_code_PinsrdImm dst immediate index tmp);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s2, va_fc2) = va_lemma_Mov64 (va_hd va_b1) va_s0 (va_coerce_reg_opr64_to_dst_opr64 tmp)
(va_const_opr64 immediate) in
let va_b2 = va_tl va_b1 in
let (va_s3, va_fc3) = va_lemma_Pinsrd (va_hd va_b2) va_s2 dst (va_coerce_reg_opr64_to_opr64 tmp)
index in
let va_b3 = va_tl va_b2 in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_f2 = va_lemma_merge_total va_b2 va_s2 va_fc3 va_s3 va_f3 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc2 va_s2 va_f2 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PinsrdImm dst immediate index tmp va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PinsrdImm (va_code_PinsrdImm dst immediate index tmp) va_s0 dst
immediate index tmp in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_reg_opr64 tmp va_sM
(va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pinsrq
[@ "opaque_to_smt"]
let va_code_Pinsrq dst src index =
(mk_ins (make_instr (I.ins_Pinsrq index) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pinsrq dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pinsrq va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pinsrq) (va_code_Pinsrq dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pinsrq index) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pinsrq index) (OReg dst) src)) va_s0
in
Vale.Def.Types_s.insert_nat64_reveal ();
assert (va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64_def (va_eval_xmm va_old_s dst)
(va_eval_opr64 va_sM src) index);
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pinsrq dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pinsrq (va_code_Pinsrq dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PinsrqImm | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
immediate: Vale.X64.Memory.nat64 ->
index: Vale.X64.Memory.nat8 ->
tmp: Vale.X64.Decls.va_operand_reg_opr64
-> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_operand_reg_opr64",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Vale.X64.InsBasic.va_code_Mov64",
"Vale.X64.Decls.va_coerce_reg_opr64_to_dst_opr64",
"Vale.X64.Decls.va_const_opr64",
"Vale.X64.InsVector.va_code_Pinsrq",
"Vale.X64.Decls.va_coerce_reg_opr64_to_opr64",
"Vale.X64.Decls.va_CNil",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_PinsrqImm dst immediate index tmp =
| (va_Block (va_CCons (va_code_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64 immediate)
)
(va_CCons (va_code_Pinsrq dst (va_coerce_reg_opr64_to_opr64 tmp) index) (va_CNil ())))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Pcmpeqd | val va_code_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | val va_code_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | let va_code_Pcmpeqd dst src =
(mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 61,
"end_line": 671,
"start_col": 0,
"start_line": 670
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufd (va_code_Pshufd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pcmpeqd | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pcmpeqd",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Pcmpeqd dst src =
| (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_VPslldq4 | val va_codegen_success_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | val va_codegen_success_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | let va_codegen_success_VPslldq4 dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 888,
"start_col": 0,
"start_line": 887
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufd (va_code_Pshufd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pcmpeqd
[@ "opaque_to_smt"]
let va_code_Pcmpeqd dst src =
(mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pcmpeqd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pcmpeqd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pcmpeqd) (va_code_Pcmpeqd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pcmpeqd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pcmpeqd (va_code_Pcmpeqd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pextrq
[@ "opaque_to_smt"]
let va_code_Pextrq dst src index =
(mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pextrq dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pextrq va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pextrq) (va_code_Pextrq dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0
in
Vale.Arch.Types.lo64_reveal ();
Vale.Arch.Types.hi64_reveal ();
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pextrq dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pextrq (va_code_Pextrq dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pinsrd
[@ "opaque_to_smt"]
let va_code_Pinsrd dst src index =
(mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pinsrd dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pinsrd va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pinsrd) (va_code_Pinsrd dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src)) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pinsrd dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pinsrd (va_code_Pinsrd dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PinsrdImm
[@ "opaque_to_smt"]
let va_code_PinsrdImm dst immediate index tmp =
(va_Block (va_CCons (va_code_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_CCons (va_code_Pinsrd dst (va_coerce_reg_opr64_to_opr64 tmp) index) (va_CNil
()))))
[@ "opaque_to_smt"]
let va_codegen_success_PinsrdImm dst immediate index tmp =
(va_pbool_and (va_codegen_success_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_pbool_and (va_codegen_success_Pinsrd dst (va_coerce_reg_opr64_to_opr64 tmp)
index) (va_ttrue ())))
[@"opaque_to_smt"]
let va_lemma_PinsrdImm va_b0 va_s0 dst immediate index tmp =
va_reveal_opaque (`%va_code_PinsrdImm) (va_code_PinsrdImm dst immediate index tmp);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s2, va_fc2) = va_lemma_Mov64 (va_hd va_b1) va_s0 (va_coerce_reg_opr64_to_dst_opr64 tmp)
(va_const_opr64 immediate) in
let va_b2 = va_tl va_b1 in
let (va_s3, va_fc3) = va_lemma_Pinsrd (va_hd va_b2) va_s2 dst (va_coerce_reg_opr64_to_opr64 tmp)
index in
let va_b3 = va_tl va_b2 in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_f2 = va_lemma_merge_total va_b2 va_s2 va_fc3 va_s3 va_f3 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc2 va_s2 va_f2 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PinsrdImm dst immediate index tmp va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PinsrdImm (va_code_PinsrdImm dst immediate index tmp) va_s0 dst
immediate index tmp in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_reg_opr64 tmp va_sM
(va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pinsrq
[@ "opaque_to_smt"]
let va_code_Pinsrq dst src index =
(mk_ins (make_instr (I.ins_Pinsrq index) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pinsrq dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pinsrq va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pinsrq) (va_code_Pinsrq dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pinsrq index) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pinsrq index) (OReg dst) src)) va_s0
in
Vale.Def.Types_s.insert_nat64_reveal ();
assert (va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64_def (va_eval_xmm va_old_s dst)
(va_eval_opr64 va_sM src) index);
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pinsrq dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pinsrq (va_code_Pinsrq dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PinsrqImm
[@ "opaque_to_smt"]
let va_code_PinsrqImm dst immediate index tmp =
(va_Block (va_CCons (va_code_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_CCons (va_code_Pinsrq dst (va_coerce_reg_opr64_to_opr64 tmp) index) (va_CNil
()))))
[@ "opaque_to_smt"]
let va_codegen_success_PinsrqImm dst immediate index tmp =
(va_pbool_and (va_codegen_success_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_pbool_and (va_codegen_success_Pinsrq dst (va_coerce_reg_opr64_to_opr64 tmp)
index) (va_ttrue ())))
[@"opaque_to_smt"]
let va_lemma_PinsrqImm va_b0 va_s0 dst immediate index tmp =
va_reveal_opaque (`%va_code_PinsrqImm) (va_code_PinsrqImm dst immediate index tmp);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s2, va_fc2) = va_lemma_Mov64 (va_hd va_b1) va_s0 (va_coerce_reg_opr64_to_dst_opr64 tmp)
(va_const_opr64 immediate) in
let va_b2 = va_tl va_b1 in
let (va_s3, va_fc3) = va_lemma_Pinsrq (va_hd va_b2) va_s2 dst (va_coerce_reg_opr64_to_opr64 tmp)
index in
let va_b3 = va_tl va_b2 in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_f2 = va_lemma_merge_total va_b2 va_s2 va_fc3 va_s3 va_f3 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc2 va_s2 va_f2 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PinsrqImm dst immediate index tmp va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PinsrqImm (va_code_PinsrqImm dst immediate index tmp) va_s0 dst
immediate index tmp in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_reg_opr64 tmp va_sM
(va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- VPslldq4
[@ "opaque_to_smt"]
let va_code_VPslldq4 dst src =
(mk_ins (make_instr (I.ins_VPslldq 4) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_VPslldq4 dst src =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_codegen_success_Vpslldq8 | val va_codegen_success_Vpslldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | val va_codegen_success_Vpslldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | let va_codegen_success_Vpslldq8 dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 918,
"start_col": 0,
"start_line": 917
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufd (va_code_Pshufd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pcmpeqd
[@ "opaque_to_smt"]
let va_code_Pcmpeqd dst src =
(mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pcmpeqd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pcmpeqd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pcmpeqd) (va_code_Pcmpeqd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pcmpeqd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pcmpeqd (va_code_Pcmpeqd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pextrq
[@ "opaque_to_smt"]
let va_code_Pextrq dst src index =
(mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pextrq dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pextrq va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pextrq) (va_code_Pextrq dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0
in
Vale.Arch.Types.lo64_reveal ();
Vale.Arch.Types.hi64_reveal ();
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pextrq dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pextrq (va_code_Pextrq dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pinsrd
[@ "opaque_to_smt"]
let va_code_Pinsrd dst src index =
(mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pinsrd dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pinsrd va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pinsrd) (va_code_Pinsrd dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src)) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pinsrd dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pinsrd (va_code_Pinsrd dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PinsrdImm
[@ "opaque_to_smt"]
let va_code_PinsrdImm dst immediate index tmp =
(va_Block (va_CCons (va_code_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_CCons (va_code_Pinsrd dst (va_coerce_reg_opr64_to_opr64 tmp) index) (va_CNil
()))))
[@ "opaque_to_smt"]
let va_codegen_success_PinsrdImm dst immediate index tmp =
(va_pbool_and (va_codegen_success_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_pbool_and (va_codegen_success_Pinsrd dst (va_coerce_reg_opr64_to_opr64 tmp)
index) (va_ttrue ())))
[@"opaque_to_smt"]
let va_lemma_PinsrdImm va_b0 va_s0 dst immediate index tmp =
va_reveal_opaque (`%va_code_PinsrdImm) (va_code_PinsrdImm dst immediate index tmp);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s2, va_fc2) = va_lemma_Mov64 (va_hd va_b1) va_s0 (va_coerce_reg_opr64_to_dst_opr64 tmp)
(va_const_opr64 immediate) in
let va_b2 = va_tl va_b1 in
let (va_s3, va_fc3) = va_lemma_Pinsrd (va_hd va_b2) va_s2 dst (va_coerce_reg_opr64_to_opr64 tmp)
index in
let va_b3 = va_tl va_b2 in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_f2 = va_lemma_merge_total va_b2 va_s2 va_fc3 va_s3 va_f3 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc2 va_s2 va_f2 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PinsrdImm dst immediate index tmp va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PinsrdImm (va_code_PinsrdImm dst immediate index tmp) va_s0 dst
immediate index tmp in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_reg_opr64 tmp va_sM
(va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pinsrq
[@ "opaque_to_smt"]
let va_code_Pinsrq dst src index =
(mk_ins (make_instr (I.ins_Pinsrq index) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pinsrq dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pinsrq va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pinsrq) (va_code_Pinsrq dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pinsrq index) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pinsrq index) (OReg dst) src)) va_s0
in
Vale.Def.Types_s.insert_nat64_reveal ();
assert (va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64_def (va_eval_xmm va_old_s dst)
(va_eval_opr64 va_sM src) index);
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pinsrq dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pinsrq (va_code_Pinsrq dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PinsrqImm
[@ "opaque_to_smt"]
let va_code_PinsrqImm dst immediate index tmp =
(va_Block (va_CCons (va_code_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_CCons (va_code_Pinsrq dst (va_coerce_reg_opr64_to_opr64 tmp) index) (va_CNil
()))))
[@ "opaque_to_smt"]
let va_codegen_success_PinsrqImm dst immediate index tmp =
(va_pbool_and (va_codegen_success_Mov64 (va_coerce_reg_opr64_to_dst_opr64 tmp) (va_const_opr64
immediate)) (va_pbool_and (va_codegen_success_Pinsrq dst (va_coerce_reg_opr64_to_opr64 tmp)
index) (va_ttrue ())))
[@"opaque_to_smt"]
let va_lemma_PinsrqImm va_b0 va_s0 dst immediate index tmp =
va_reveal_opaque (`%va_code_PinsrqImm) (va_code_PinsrqImm dst immediate index tmp);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let (va_s2, va_fc2) = va_lemma_Mov64 (va_hd va_b1) va_s0 (va_coerce_reg_opr64_to_dst_opr64 tmp)
(va_const_opr64 immediate) in
let va_b2 = va_tl va_b1 in
let (va_s3, va_fc3) = va_lemma_Pinsrq (va_hd va_b2) va_s2 dst (va_coerce_reg_opr64_to_opr64 tmp)
index in
let va_b3 = va_tl va_b2 in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_f2 = va_lemma_merge_total va_b2 va_s2 va_fc3 va_s3 va_f3 va_sM in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc2 va_s2 va_f2 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PinsrqImm dst immediate index tmp va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PinsrqImm (va_code_PinsrqImm dst immediate index tmp) va_s0 dst
immediate index tmp in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_reg_opr64 tmp va_sM
(va_update_operand_xmm dst va_sM va_s0))));
va_lemma_norm_mods ([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- VPslldq4
[@ "opaque_to_smt"]
let va_code_VPslldq4 dst src =
(mk_ins (make_instr (I.ins_VPslldq 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_VPslldq4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPslldq4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_VPslldq4) (va_code_VPslldq4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPslldq 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPslldq 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPslldq4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPslldq4 (va_code_VPslldq4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Vpslldq8
[@ "opaque_to_smt"]
let va_code_Vpslldq8 dst src =
(mk_ins (make_instr (I.ins_VPslldq 8) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Vpslldq8 dst src =
| (va_ttrue ()) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Pextrq | val va_code_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot va_code | val va_code_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot va_code | let va_code_Pextrq dst src index =
(mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 59,
"end_line": 701,
"start_col": 0,
"start_line": 700
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufd (va_code_Pshufd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pcmpeqd
[@ "opaque_to_smt"]
let va_code_Pcmpeqd dst src =
(mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pcmpeqd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pcmpeqd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pcmpeqd) (va_code_Pcmpeqd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pcmpeqd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pcmpeqd (va_code_Pcmpeqd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pextrq | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_dst_opr64 ->
src: Vale.X64.Decls.va_operand_xmm ->
index: Vale.X64.Memory.nat8
-> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.opXmm",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pextrq",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Pextrq dst src index =
| (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_wpProof_Pextrq | val va_wpProof_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Pextrq dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pextrq dst src index)
([va_mod_dst_opr64 dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Pextrq dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pextrq dst src index)
([va_mod_dst_opr64 dst]) va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_Pextrq dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pextrq (va_code_Pextrq dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 726,
"start_col": 0,
"start_line": 720
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufd (va_code_Pshufd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pcmpeqd
[@ "opaque_to_smt"]
let va_code_Pcmpeqd dst src =
(mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pcmpeqd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pcmpeqd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pcmpeqd) (va_code_Pcmpeqd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pcmpeqd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pcmpeqd (va_code_Pcmpeqd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pextrq
[@ "opaque_to_smt"]
let va_code_Pextrq dst src index =
(mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pextrq dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pextrq va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pextrq) (va_code_Pextrq dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0
in
Vale.Arch.Types.lo64_reveal ();
Vale.Arch.Types.hi64_reveal ();
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_dst_opr64 ->
src: Vale.X64.Decls.va_operand_xmm ->
index: Vale.X64.Memory.nat8 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_mod_dst_opr64",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_dst_opr64",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.InsVector.va_lemma_Pextrq",
"Vale.X64.InsVector.va_code_Pextrq"
] | [] | false | false | false | false | false | let va_wpProof_Pextrq dst src index va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Pextrq (va_code_Pextrq dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_lemma_Pshufd | val va_lemma_Pshufd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> permutation:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pshufd dst src permutation) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Types_s.select_word (va_eval_xmm va_s0 src)
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.Def.Types_s.byte_to_twobits permutation)))
(Vale.Def.Types_s.select_word (va_eval_xmm va_s0 src)
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (Vale.Def.Types_s.byte_to_twobits permutation)))
(Vale.Def.Types_s.select_word (va_eval_xmm va_s0 src)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (Vale.Def.Types_s.byte_to_twobits permutation)))
(Vale.Def.Types_s.select_word (va_eval_xmm va_s0 src)
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (Vale.Def.Types_s.byte_to_twobits permutation))) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | val va_lemma_Pshufd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> permutation:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pshufd dst src permutation) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(Vale.Def.Types_s.select_word (va_eval_xmm va_s0 src)
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (Vale.Def.Types_s.byte_to_twobits permutation)))
(Vale.Def.Types_s.select_word (va_eval_xmm va_s0 src)
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (Vale.Def.Types_s.byte_to_twobits permutation)))
(Vale.Def.Types_s.select_word (va_eval_xmm va_s0 src)
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (Vale.Def.Types_s.byte_to_twobits permutation)))
(Vale.Def.Types_s.select_word (va_eval_xmm va_s0 src)
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (Vale.Def.Types_s.byte_to_twobits permutation))) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 653,
"start_col": 0,
"start_line": 647
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ()) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
permutation: Vale.X64.Memory.nat8
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Vale.X64.Decls.va_eval_ins",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pshufd",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Prims.unit",
"Vale.X64.Decls.va_ins_lemma",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.X64.InsVector.va_code_Pshufd"
] | [] | false | false | false | false | false | let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
| va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let va_old_s:va_state = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let va_sM, va_fM =
va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM) | false |
Vale.X64.InsVector.fst | Vale.X64.InsVector.va_code_Pinsrd | val va_code_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code | val va_code_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code | let va_code_Pinsrd dst src index =
(mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src)) | {
"file_name": "obj/Vale.X64.InsVector.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 59,
"end_line": 733,
"start_col": 0,
"start_line": 732
} | module Vale.X64.InsVector
open Vale.Def.Opaque_s
open Vale.X64
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Memory
open Vale.X64.Stack_i
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 2 --max_fuel 4 --max_ifuel 2 --z3rlimit 50"
//-- Mem128_in
//--
//-- Mem128_lemma
[@ "opaque_to_smt"]
let va_code_Mem128_lemma () =
(va_Block (va_CNil ()))
[@ "opaque_to_smt"]
let va_codegen_success_Mem128_lemma () =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Mem128_lemma va_b0 va_s0 h base offset t b index =
va_reveal_opaque (`%va_code_Mem128_lemma) (va_code_Mem128_lemma ());
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
let heap_h = va_get_mem_heaplet h va_s0 in
lemma_opr_Mem128 h va_s0 base offset t b index;
let (va_sM, va_fM) = va_lemma_empty_total va_s0 va_b1 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Mem128_lemma h base offset t b index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Mem128_lemma (va_code_Mem128_lemma ()) va_s0 h base offset t b
index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM va_s0));
va_lemma_norm_mods ([]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Paddd
[@ "opaque_to_smt"]
let va_code_Paddd dst src =
(mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Paddd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Paddd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Paddd) (va_code_Paddd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Paddd) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Paddd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Paddd (va_code_Paddd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPaddd
[@ "opaque_to_smt"]
let va_code_VPaddd dst src1 src2 =
(mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPaddd dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPaddd va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPaddd) (va_code_VPaddd dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPaddd) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPaddd dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPaddd (va_code_VPaddd dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pxor
[@ "opaque_to_smt"]
let va_code_Pxor dst src =
(mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pxor dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pxor va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pxor) (va_code_Pxor dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ()) (OReg dst) (OReg
src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_Pxor) (S.AnnotatePxor ())
(OReg dst) (OReg src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pxor dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pxor (va_code_Pxor dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 3 --z3rlimit 50"
//-- Pand
[@ "opaque_to_smt"]
let va_code_Pand dst src =
(mk_ins (make_instr (I.ins_Pand) (OReg dst) src))
[@ "opaque_to_smt"]
let va_codegen_success_Pand dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pand va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pand) (va_code_Pand dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pand) (OReg dst) src)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pand dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pand (va_code_Pand dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPxor
[@ "opaque_to_smt"]
let va_code_VPxor dst src1 src2 =
(mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg src1) src2))
[@ "opaque_to_smt"]
let va_codegen_success_VPxor dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPxor va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPxor) (va_code_VPxor dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ()) (OReg dst) (OReg
src1) src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr_annotate (I.ins_VPxor) (S.AnnotateVPxor ())
(OReg dst) (OReg src1) src2)) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPxor dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPxor (va_code_VPxor dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pslld
[@ "opaque_to_smt"]
let va_code_Pslld dst amt =
(mk_ins (make_instr (I.ins_Pslld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Pslld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pslld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Pslld) (va_code_Pslld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pslld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pslld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pslld (va_code_Pslld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrld
[@ "opaque_to_smt"]
let va_code_Psrld dst amt =
(mk_ins (make_instr (I.ins_Psrld amt) (OReg dst)))
[@ "opaque_to_smt"]
let va_codegen_success_Psrld dst amt =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Psrld va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrld) (va_code_Psrld dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrld amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Psrld dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrld (va_code_Psrld dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Psrldq
val va_code_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_code
[@ "opaque_to_smt"]
let va_code_Psrldq dst amt =
(mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst)))
val va_codegen_success_Psrldq : dst:va_operand_xmm -> amt:int -> Tot va_pbool
[@ "opaque_to_smt"]
let va_codegen_success_Psrldq dst amt =
(va_ttrue ())
val va_lemma_Psrldq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> amt:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Psrldq dst amt) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad =
FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))))
[@"opaque_to_smt"]
let va_lemma_Psrldq va_b0 va_s0 dst amt =
va_reveal_opaque (`%va_code_Psrldq) (va_code_Psrldq dst amt);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Psrldq amt) (OReg dst))) va_s0 in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_Psrldq (dst:va_operand_xmm) (amt:int) (va_s0:va_state) (va_k:(va_state -> unit -> Type0))
: Type0 =
(va_is_dst_xmm dst va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (0 <= amt /\ amt < 16) /\ (forall
(va_x_dst:va_value_xmm) . let va_sM = va_upd_operand_xmm dst va_x_dst va_s0 in va_get_ok va_sM
/\ (let src_bytes = Vale.Def.Types_s.le_quad32_to_bytes (va_eval_xmm va_s0 dst) in let zero_pad
= FStar.Seq.Base.create #nat8 amt 0 in let remaining_bytes = FStar.Seq.Base.slice
#Vale.Def.Types_s.nat8 src_bytes amt (FStar.Seq.Base.length #Vale.Def.Types_s.nat8 src_bytes)
in va_eval_xmm va_sM dst == Vale.Def.Types_s.le_bytes_to_quad32 (FStar.Seq.Base.append #nat8
zero_pad remaining_bytes)) ==> va_k va_sM (())))
val va_wpProof_Psrldq : dst:va_operand_xmm -> amt:int -> va_s0:va_state -> va_k:(va_state -> unit
-> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Psrldq dst amt va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Psrldq dst amt) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_Psrldq dst amt va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Psrldq (va_code_Psrldq dst amt) va_s0 dst amt in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrldq (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrldq dst amt)) =
(va_QProc (va_code_Psrldq dst amt) ([va_mod_xmm dst]) (va_wp_Psrldq dst amt) (va_wpProof_Psrldq
dst amt))
//--
//-- Palignr4
[@ "opaque_to_smt"]
let va_code_Palignr4 dst src =
(mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr4 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr4 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr4) (va_code_Palignr4 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 4) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr4 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr4 (va_code_Palignr4 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Palignr8
[@ "opaque_to_smt"]
let va_code_Palignr8 dst src =
(mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Palignr8 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Palignr8 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Palignr8) (va_code_Palignr8 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Palignr 8) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Palignr8 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Palignr8 (va_code_Palignr8 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPalignr8
[@ "opaque_to_smt"]
let va_code_VPalignr8 dst src1 src2 =
(mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPalignr8 dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPalignr8 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPalignr8) (va_code_VPalignr8 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPalignr 8) (OReg dst) (OReg src1)
(OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPalignr8 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPalignr8 (va_code_VPalignr8 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Shufpd
[@ "opaque_to_smt"]
let va_code_Shufpd dst src permutation =
(mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Shufpd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Shufpd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Shufpd) (va_code_Shufpd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Shufpd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Shufpd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Shufpd (va_code_Shufpd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VShufpd
[@ "opaque_to_smt"]
let va_code_VShufpd dst src1 src2 permutation =
(mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VShufpd dst src1 src2 permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VShufpd va_b0 va_s0 dst src1 src2 permutation =
va_reveal_opaque (`%va_code_VShufpd) (va_code_VShufpd dst src1 src2 permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg src1) (OReg src2)))
va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VShufpd permutation) (OReg dst) (OReg
src1) (OReg src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VShufpd dst src1 src2 permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VShufpd (va_code_VShufpd dst src1 src2 permutation) va_s0 dst src1
src2 permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb
[@ "opaque_to_smt"]
let va_code_Pshufb dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb) (va_code_Pshufb dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb (va_code_Pshufb dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- VPshufb
[@ "opaque_to_smt"]
let va_code_VPshufb dst src1 src2 =
(mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2)))
[@ "opaque_to_smt"]
let va_codegen_success_VPshufb dst src1 src2 =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_VPshufb va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_VPshufb) (va_code_VPshufb dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg src2))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_VPshufb) (OReg dst) (OReg src1) (OReg
src2))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_VPshufb dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_VPshufb (va_code_VPshufb dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbStable
[@ "opaque_to_smt"]
let va_code_PshufbStable dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbStable dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbStable va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbStable) (va_code_PshufbStable dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbStable dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbStable (va_code_PshufbStable dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- PshufbDup
[@ "opaque_to_smt"]
let va_code_PshufbDup dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_PshufbDup dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_PshufbDup va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_PshufbDup) (va_code_PshufbDup dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_PshufbDup dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_PshufbDup (va_code_PshufbDup dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufb64
[@ "opaque_to_smt"]
let va_code_Pshufb64 dst src =
(mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufb64 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufb64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pshufb64) (va_code_Pshufb64 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufb) (OReg dst) (OReg src))) va_s0
in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufb64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufb64 (va_code_Pshufb64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst
va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pshufd
[@ "opaque_to_smt"]
let va_code_Pshufd dst src permutation =
(mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pshufd dst src permutation =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pshufd va_b0 va_s0 dst src permutation =
va_reveal_opaque (`%va_code_Pshufd) (va_code_Pshufd dst src permutation);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pshufd permutation) (OReg dst) (OReg
src))) va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pshufd dst src permutation va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pshufd (va_code_Pshufd dst src permutation) va_s0 dst src
permutation in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pcmpeqd
[@ "opaque_to_smt"]
let va_code_Pcmpeqd dst src =
(mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pcmpeqd dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pcmpeqd va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Pcmpeqd) (va_code_Pcmpeqd dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pcmpeqd) (OReg dst) (OReg src)))
va_s0 in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pcmpeqd dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pcmpeqd (va_code_Pcmpeqd dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pextrq
[@ "opaque_to_smt"]
let va_code_Pextrq dst src index =
(mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_Pextrq dst src index =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_Pextrq va_b0 va_s0 dst src index =
va_reveal_opaque (`%va_code_Pextrq) (va_code_Pextrq dst src index);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_Pextrq index) dst (OReg src))) va_s0
in
Vale.Arch.Types.lo64_reveal ();
Vale.Arch.Types.hi64_reveal ();
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Pextrq dst src index va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Pextrq (va_code_Pextrq dst src index) va_s0 dst src index in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Pinsrd | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsVector.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"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.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"max_ifuel": 3,
"no_plugins": false,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_opr64 ->
index: Vale.X64.Memory.nat8
-> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Memory.nat8",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.op64",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Pinsrd",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Pinsrd dst src index =
| (mk_ins (make_instr (I.ins_Pinsrd index) (OReg dst) src)) | false |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.